Update tile57 to main: the ownership partition is the engine's, not ours

tile57's compose ABI now finds/reuses/rebuilds the ownership partition
beside the archives itself (compose_open/compose_tree dropped partition_path;
compose_save_partition is gone). Drop all the host-side sidecar plumbing:
NewComposer no longer takes a partitionPath, Composer.SavePartition and
livePartitionPath are deleted, bake.go stops writing partition.tpart, and
openLiveComposer just opens — no load, no save. Fixes the StalePartition
dance that forced a blocking owned-face rebuild at boot on an engine bump.

Bumps the tile57 submodule to origin/main (2c36da6, PR #31 label-cache).

Author: beetlebugorg

cmd/chartplotter/bake.go

@@ -79,18 +79,16 @@ func (c bakeCmd) Run() error {
 		return fmt.Errorf("no coverage: no valid S-57 cells under %s", input)
 	}
 
-	// Build + save the ownership-partition sidecar next to the tiles (the compositor loads it on
-	// open to skip the build).
-	comp, err := tilesource.NewComposer(paths, "")
+	// Pre-warm the ownership partition: opening a compositor over the freshly baked cells
+	// builds it and persists it beside the archives, so the runtime open doesn't pay the
+	// owned-face build. (The engine owns the sidecar now — nothing to save by hand.)
+	comp, err := tilesource.NewComposer(paths)
 	if err != nil {
 		return err
 	}
 	defer comp.Close()
-	if err := comp.SavePartition(filepath.Join(outDir, "partition.tpart")); err != nil {
-		return err
-	}
 	m := comp.Meta()
-	fmt.Printf("baked %d cell(s) → %s/tiles/*.pmtiles + partition.tpart (z%d..%d, bounds %.4f,%.4f,%.4f,%.4f)\n",
+	fmt.Printf("baked %d cell(s) → %s/tiles/*.pmtiles (z%d..%d, bounds %.4f,%.4f,%.4f,%.4f)\n",
 		len(paths), outDir, m.MinZoom, m.MaxZoom, m.W, m.S, m.E, m.N)
 	return nil
 }

internal/engine/server/live_compose.go

@@ -47,7 +47,7 @@ func (s *Server) registerLiveCompose() {
 	if name == "" {
 		name = "live"
 	}
-	src, err := tilesource.NewComposer(paths, os.Getenv("TILE57_LIVE_PARTITION"))
+	src, err := tilesource.NewComposer(paths)
 	if err != nil {
 		log.Printf("live-compose: open %s failed: %v", dir, err)
 		return

internal/engine/server/live_provider.go

@@ -18,17 +18,13 @@ import (
 )
 
 // liveCellsDir is <setDir>/tiles — the KEPT per-cell PMTiles the runtime compositor mmaps.
-// This is the same layout `tile57 bake -o <dir>` writes (<dir>/tiles/<STEM>.pmtiles next to
-// <dir>/partition.tpart), so a CLI-baked structure drops straight into a provider's set dir.
+// This is the same layout `tile57 bake -o <dir>` writes (<dir>/tiles/<STEM>.pmtiles), so a
+// CLI-baked structure drops straight into a provider's set dir. The engine keeps its own
+// ownership-partition sidecar beside these archives; the host neither writes nor reads it.
 func (s *Server) liveCellsDir(provider string) string {
 	return filepath.Join(s.setDir(provider), "tiles")
 }
 
-// livePartitionPath is <setDir>/partition.tpart — the saved ownership-partition sidecar.
-func (s *Server) livePartitionPath(provider string) string {
-	return filepath.Join(s.setDir(provider), "partition.tpart")
-}
-
 // liveGenPath is <setDir>/live.gen — it holds the provider's CONTENT cache-bust token (a
 // decimal of the sha-of-shas over its per-cell archives; see liveGenToken), which packGen reads
 // and stamps into tile URLs as ?g. It changes exactly when the cell set or any cell's content
@@ -125,23 +121,10 @@ func (s *Server) openLiveComposer(provider string) (*tilesource.Composer, error)
 	if len(paths) == 0 {
 		return nil, nil
 	}
-	sidecar := s.livePartitionPath(provider)
-	load := ""
-	if fi, err := os.Stat(sidecar); err == nil && fi.Size() > 0 {
-		load = sidecar
-	}
-	c, err := tilesource.NewComposer(paths, load)
-	if err != nil {
-		return nil, err
-	}
-	// Persist the (possibly rebuilt) partition so the on-disk sidecar always matches the current
-	// cell set: a progressive re-key or an added/removed district changes the inputs, the
-	// compositor rebuilds from a stale sidecar, and saving keeps the sidecar current for a fast
-	// boot. (When the sidecar was loaded intact this re-writes identical bytes.)
-	if err := c.SavePartition(sidecar); err != nil {
-		log.Printf("live %s: save partition sidecar: %v", provider, err)
-	}
-	return c, nil
+	// The engine owns the ownership partition now: NewComposer finds it beside the archives,
+	// reuses it when it still matches the cell set, and rebuilds + refreshes it on disk when it
+	// does not. Nothing to load or save here.
+	return tilesource.NewComposer(paths)
 }
 
 // progressiveReKey re-opens the live compositor over the cells baked SO FAR, registers it as the

internal/engine/tilesource/composer.go

@@ -15,11 +15,12 @@ type Composer struct {
 }
 
 // NewComposer opens a runtime compositor over the per-cell PMTiles at paths (each from
-// `tile57 compose --keep-cells` / tile57.BakeChart). partitionPath (or "") names a partition
-// sidecar (`tile57 compose --save-partition`) to load and skip the owned-face build. Close it
+// `tile57 compose --keep-cells` / tile57.BakeChart). The ownership partition is an internal
+// detail of the engine now — found beside the archives, reused when it still matches the cell
+// set, and rebuilt (and refreshed on disk) when it does not; nothing to pass or manage. Close it
 // when done — callers must not Close while any request can still call Tile.
-func NewComposer(paths []string, partitionPath string) (*Composer, error) {
-	src, err := tile57.OpenCompose(paths, partitionPath)
+func NewComposer(paths []string) (*Composer, error) {
+	src, err := tile57.OpenCompose(paths)
 	if err != nil {
 		return nil, err
 	}
@@ -62,9 +63,5 @@ func (c *Composer) TileOwned(z uint8, x, y uint32) (body []byte, owned bool, err
 // Meta returns the compositor's display metadata (zoom range + coverage bounds).
 func (c *Composer) Meta() TileMeta { return c.meta }
 
-// SavePartition persists the resident ownership partition to path, so a later NewComposer can load
-// it (as partitionPath) and skip the owned-face build.
-func (c *Composer) SavePartition(path string) error { return c.src.SavePartition(path) }
-
 // Close releases the compositor (io.Closer, so tilesource.Close finds it).
 func (c *Composer) Close() error { return c.src.Close() }