@voltro/plugin-rooms 0.0.0-stage → 0.88.0

package/dist/geometryServer.d.ts

@@ -0,0 +1,2766 @@
+import { Context } from 'effect';
+import { DataStore } from '@voltro/database';
+import { Duration } from 'effect';
+import { Effect } from 'effect';
+import { HotError } from '@voltro/kv/hot/contract';
+import { HotStoreShape } from '@voltro/kv/hot/contract';
+import { Layer } from 'effect';
+import { Option as Option_2 } from 'effect';
+import { PluginBindContext } from '@voltro/protocol';
+import { PluginHttpRoute } from '@voltro/protocol';
+import { PluginHttpRouteRequest } from '@voltro/protocol';
+import { PluginPrivacyHookContext } from '@voltro/protocol';
+import { Row } from '@voltro/database';
+import { Schema } from 'effect';
+import { StorageObjectMetadata } from '@voltro/plugin-storage';
+import { StorageServiceShape } from '@voltro/plugin-storage';
+import { Subject } from '@voltro/protocol';
+import { TableLike } from '@voltro/database';
+import { VoltroPlugin } from '@voltro/protocol';
+import { WorkflowEngine } from 'effect/workflow/WorkflowEngine';
+import { WorkflowInstance } from 'effect/workflow/WorkflowEngine';
+import { YieldableError } from 'effect/Cause';
+
+/** Configuration consumers never invoke a player callback. Its player type
+ * stays author-owned; this inventory type does not erase it into an input. */
+declare type AnyWorldDescriptor = WorldDescriptor<never>;
+
+export declare interface AppStorageGeometry extends GeometryStorage {
+    /** Chunk URLs for players from the same Storage (`sqlRoomsGeometry({ reads })` with
+     * `roomsPlugin({ geometryReadUrls: true })`). Needs `visibility: 'public'`: a private object is readable by its
+     * owner only. Borrowed at the first grant, like `source`. */
+    readonly readGrants: (options: Omit<GeometryStorageReadGrantOptions, 'bucket' | 'metadata' | 'visibility'>) => GeometryStorageReadGrants;
+}
+
+/** Static geometry bytes in the app's own Storage plugin, on the API and on every Rooms Host (the CLI Host binds
+ * the app's Storage when a World declares geometry). The Storage is borrowed at first use, after binding; a
+ * Storage that is missing, ambiguous or unbound fails that operation. Use a provider both processes share
+ * (`database`, `filesystem`, S3/MinIO/Azure); memory Storage is private to one process. */
+export declare const appStorageGeometry: (plugins: ReadonlyArray<VoltroPlugin>, options: Omit<GeometryStorageOptions, "bucket" | "metadata">) => AppStorageGeometry;
+
+/** Registry and tenant HotStore are borrowed from the ordinary plugin context.
+ * A degraded read policy cannot grant a lease. The app owns connections/lifetime. */
+export declare const bindGeometryChunkLeases: (context: Pick<PluginBindContext, "connectionRegistry" | "hotStore">, options: GeometryChunkLeaseOptions) => Promise<GeometryChunkLeases>;
+
+/** Borrow the actual existing registry and tenant HotStore accessor. No private
+ * Redis/client/fallback/pool/timer is created and no connections are closed. */
+export declare const bindRoomGeometryReloadSource: (context: Pick<PluginBindContext, "connectionRegistry" | "hotStore">, offered: BoundRoomGeometryReloadSourceOptions) => Context.Service.Shape<typeof RoomGeometryReloadPort>;
+
+/** Ordinary connection registry and tenant HotStore port only. Missing registry
+ * refuses before acquisition. No private Redis pool/read fallback/owned connection. */
+export declare const bindRoomGeometryRollbackSource: (context: Pick<PluginBindContext, "connectionRegistry" | "hotStore">, offered: BoundRoomGeometryRollbackSourceOptions) => Context.Service.Shape<typeof RoomGeometryRollbackPort>;
+
+export declare interface BoundRoomGeometryReloadSourceOptions extends Omit<RoomGeometryReloadSourceOptions, 'leases'> {
+    readonly namespace: string;
+    readonly ttlMs: number;
+}
+
+export declare interface BoundRoomGeometryRollbackSourceOptions extends Omit<RoomGeometryRollbackSourceOptions, 'leases'> {
+    readonly namespace: string;
+    readonly ttlMs: number;
+}
+
+declare class BudgetExceeded extends BudgetExceeded_base {
+    get message(): string;
+}
+
+declare const BudgetExceeded_base: Schema.Class<BudgetExceeded, Schema.TaggedStruct<"BudgetExceeded", {
+    readonly budget: Schema.String;
+    readonly limit: Schema.Number;
+}>, YieldableError>;
+
+export declare const captureGeometryMigrationReceipt: (offered: unknown) => GeometryMigrationReceipt;
+
+export declare const captureGeometryMigrationRequest: (offered: unknown) => GeometryMigrationRequest;
+
+export declare const captureGeometryStreamManifest: (offered: unknown, maximumChunks?: number, maximumBytes?: number) => GeometryStreamManifest;
+
+export declare const captureRoomGeometryReloadPort: (offered: Context.Service.Shape<typeof RoomGeometryReloadPort>) => Context.Service.Shape<typeof RoomGeometryReloadPort>;
+
+export declare const captureRoomGeometryReloadRequest: (offered: RoomGeometryReloadRequest) => RoomGeometryReloadRequest;
+
+export declare const captureRoomGeometryRollbackPort: (offered: Context.Service.Shape<typeof RoomGeometryRollbackPort>) => Context.Service.Shape<typeof RoomGeometryRollbackPort>;
+
+export declare const captureRoomGeometryRollbackRequest: (offered: RoomGeometryRollbackRequest) => RoomGeometryRollbackRequest;
+
+declare type CollisionBody2D = {
+    readonly kind: 'circle';
+    readonly radius: number;
+} | {
+    readonly kind: 'aabb';
+    readonly halfWidth: number;
+    readonly halfHeight: number;
+};
+
+declare interface CollisionResult2D {
+    readonly transform: Transform2D;
+    readonly collided: ReadonlyArray<string>;
+    readonly iterations: number;
+}
+
+/** Borrow the original SQL/Control services; no pool, Host allocation, retry,
+ * Room/World selection from caller state or Tick access. Actual owner is read
+ * again around the authenticated Host operation; these are SQL observations. */
+export declare const dataStoreGeometryAdministration: (store: DataStore, offered: GeometryAdministrationOptions) => Context.Service.Shape<typeof RoomGeometryAdministrationPort>;
+
+/** Actual immutable geometry SQL receipt -> native private Storage -> durable
+ * SQL index. Unknown index reply rechecks the same row/reference and actual S2.
+ * This source never removes inline patches or admission receipts. */
+export declare const dataStoreGeometryJournalArchiveIndex: (store: DataStore, offered: GeometryJournalArchiveIndexOptions) => Context.Service.Shape<typeof GeometryJournalArchiveIndexPort>;
+
+/** Actual private S2 store/index/read verification precedes one actual SQL
+ * receipt-index transaction. Only the large inline body changes tier; no
+ * receipt/scope/owner/Subject/request digest/revision/hash is deleted or changed.
+ * Retention eligibility and accepted-reader/writer lifetime are current policy. */
+export declare const dataStoreGeometryJournalCompaction: (store: DataStore, offered: GeometryJournalCompactionOptions) => Context.Service.Shape<typeof GeometryJournalCompactionPort>;
+
+/** Explicit bounded awaited retention page, suitable for the normal workflow
+ * owner. No timer, private pool, partition deletion or receipt expiry invented.
+ * Only current eligible full bodies invoke actual confirmed compaction. */
+export declare const dataStoreGeometryJournalRetention: (store: DataStore, offered: GeometryJournalRetentionOptions) => Context.Service.Shape<typeof GeometryJournalRetentionPort>;
+
+/** Bounded complete SQL scope inventory before mutation. Excess inventory fails
+ * instead of endlessly revisiting the first page. Current net deltas and all
+ * admission receipts remain untouched. No timer, pool or actor work is owned. */
+export declare const dataStoreGeometryJournalRetentionSweep: (store: DataStore, offered: GeometryJournalRetentionSweepOptions) => Context.Service.Shape<typeof GeometryJournalRetentionSweepPort>;
+
+/** Same borrowed SQL tables/source; no new truth, pool, mutation or Tick read.
+ * At most one exact indexed dirty-row query per admitted static reference. */
+export declare const dataStoreGeometryManifest: (store: DataStore, offered: GeometryManifestStoreOptions) => Context.Service.Shape<typeof GeometryManifestPort>;
+
+/** Borrowed SQL transaction owner only. Caller still owns CPU writer quiescence,
+ * current chunk leases, physical actor reload/client transition and complete
+ * Subject-content redaction across inherited versions. No Tick/Hot fallback. */
+export declare const dataStoreGeometryMigrations: (store: DataStore, offeredWorlds: ReadonlyArray<AnyWorldDescriptor>, offered: GeometryMigrationStoreOptions) => Context.Service.Shape<typeof GeometryVersionMigrationPort>;
+
+/** Real DataStore transactions, no SQL dialect branch/private pool/HotStore or Tick installation.
+ * External immutable blob loading and hashing precede SQL CAS. A confirmed receipt survives a later revision. */
+export declare const dataStoreGeometryPersistence: (store: DataStore, offered: GeometryPersistenceStoreOptions) => Context.Service.Shape<typeof GeometryPersistencePort>;
+
+/** Actual SQL journal and immutable baseline source. No new table, pool or
+ * automatic module. Retains every idempotency receipt. Output is preparation;
+ * original HotStore coordination and native CAS/CPU admission are separate. */
+export declare const dataStoreGeometryRollbackPreparation: (store: DataStore, offered: GeometryRollbackStoreOptions) => Context.Service.Shape<typeof GeometryRollbackPreparationPort>;
+
+/** Borrow the registered SQL/persistence services. Own only native Room CPU
+ * inventory. No listener, pool, worker or invented placement/version default. */
+export declare const dataStoreRoomHostGeometry: (store: DataStore, offered: RoomGeometryDirectoryBindingOptions) => RoomHostGeometryBinding;
+
+export declare const defaultGeometryJournalRetentionStrategies: Readonly<GeometryJournalRetentionStrategies>;
+
+/** One exported default, shared by World declaration and actual preparation. */
+export declare const defaultGeometryMigrateDelta: GeometryMigrateDelta;
+
+/** Exact reduced integer ratio over admitted coordinates/differences of magnitude <= u32.
+ * Shared 2D/3D slab arithmetic; never round a fraction before comparing it. */
+declare interface FixedSlabFraction {
+    readonly numerator: number;
+    readonly denominator: number;
+}
+
+export declare const GEO_CHUNK_DELTAS_TABLE = "_voltro_geo_chunk_deltas";
+
+export declare const GEO_JOURNAL_ARCHIVES_TABLE = "_voltro_geo_journal_archives";
+
+export declare const GEO_JOURNAL_TABLE = "_voltro_geo_journal";
+
+export declare const GEO_MIGRATIONS_TABLE = "_voltro_geo_migrations";
+
+export declare const GEO_VERSIONS_TABLE = "_voltro_geo_versions";
+
+declare interface GeometryActivation {
+    readonly _tag: 'GeometryActivation';
+    readonly receipt: GeometryPersistenceReceipt;
+}
+
+export declare interface GeometryActivationOptions {
+    readonly maxPatchBytes?: number | undefined;
+}
+
+declare interface GeometryActorInventory {
+    at(coordinate: GeometryPreparedCoordinate): GeometryPreparedEntry;
+    contains(coordinate: GeometryPreparedCoordinate): boolean;
+    /** CPU pointer activation only; a stale before-frame refuses, exact repeat is false. */
+    activate(activation: GeometryActivation): boolean;
+    /** CPU-only whole-version swap after genuine outside-Tick SQL preparation. */
+    activateVersion(activation: GeometryVersionActivation): boolean;
+    observation(): GeometryActorInventoryObservation;
+    close(): void;
+}
+
+declare interface GeometryActorInventoryObservation {
+    readonly scope: GeometryPreparedScope;
+    readonly generation: number;
+    readonly chunks: number;
+    readonly accountedBytes: number;
+    readonly closed: boolean;
+}
+
+export declare interface GeometryAdministrationOptions {
+    readonly control: Context.Service.Shape<typeof RoomGeometryControlPort>;
+    /** Actual current app scope/room/target policy; descriptor guards are additional. `request` is
+     * `null` for the read-only `'chunks'` view. */
+    readonly authorize: (operation: 'reload' | 'rollback' | 'chunks', roomId: string, request: RoomGeometryReloadRequest | RoomGeometryRollbackRequest | null, subject: Subject) => Effect.Effect<void, GeometryPersistenceError>;
+    /** The app's Worlds: with them the administration also serves the chunk view (`chunks`). */
+    readonly worlds?: ReadonlyArray<AnyWorldDescriptor>;
+    /** Changed chunks the view returns per Room (default 256). */
+    readonly maxChunks?: number;
+    /** Delta rows the view reads per call (default 4096); `truncated` reports when there were more. */
+    readonly maxScannedChunks?: number;
+}
+
+declare interface GeometryArtifact<C extends GeometryChunk = GeometryChunk> {
+    readonly chunk: C;
+    readonly blobSha256: string;
+    /** Canonical declared content/layout, excluding actual address/version only. */
+    readonly contentSha256: string;
+    bytes(): Uint8Array;
+}
+
+declare type GeometryArtifactLimits<K extends GeometryKind> = K extends '2d-tiles' ? Partial<GeometryTileLimits> : K extends '2d-heightfield' ? Partial<GeometryHeightfieldLimits> : K extends '3d-shapes' ? Partial<GeometryShapesLimits> : Partial<GeometryVoxelLimits>;
+
+export declare interface GeometryArtifactPublication {
+    readonly tenantId: string;
+    readonly version: string;
+    readonly artifacts: ReadonlyArray<GeometryArtifact>;
+}
+
+export declare interface GeometryArtifactPublicationOptions {
+    readonly maxChunks?: number | undefined;
+    readonly maxArtifactBytes?: number;
+    readonly maxManifestBytes?: number;
+    readonly maxConcurrent?: number | undefined;
+    readonly codecLimits?: {
+        readonly [K in GeometryKind]?: GeometryArtifactLimits<K>;
+    } | undefined;
+}
+
+declare interface GeometryAssetManifest extends GeometryAssetRoot {
+    readonly assets: ReadonlyArray<GeometryAssetReference>;
+    readonly manifestSha256: string;
+}
+
+export declare const geometryAssetManifestLayer: (service: Context.Service.Shape<typeof GeometryAssetManifestPort>) => Layer.Layer<GeometryAssetManifestPort>;
+
+/** Actual published SQL/CMS catalogue; replacing it never replaces current
+ * Storage authorization or attests publication from a caller's digest. */
+export declare class GeometryAssetManifestPort extends GeometryAssetManifestPort_base {
+}
+
+declare const GeometryAssetManifestPort_base: Context.ServiceClass<GeometryAssetManifestPort, "@voltro/GeometryAssetManifestPort", {
+    observe(root: GeometryAssetRoot): Effect.Effect<GeometryAssetManifest, GeometryPersistenceError>;
+}>;
+
+export declare interface GeometryAssetReadGrant {
+    readonly url: string;
+    readonly checksum: string;
+    readonly size: number;
+    readonly contentType: string;
+}
+
+export declare class GeometryAssetReadGrantPort extends GeometryAssetReadGrantPort_base {
+}
+
+declare const GeometryAssetReadGrantPort_base: Context.ServiceClass<GeometryAssetReadGrantPort, "@voltro/GeometryAssetReadGrantPort", {
+    grant(request: GeometryAssetReadRequest, subject: Subject): Effect.Effect<GeometryAssetReadGrant, GeometryPersistenceError>;
+}>;
+
+declare interface GeometryAssetReadRequest extends GeometryAssetRoot {
+    readonly key: string;
+}
+
+declare interface GeometryAssetReference {
+    readonly key: string;
+    readonly fileId: string;
+    readonly bucket: string;
+    readonly checksum: string;
+    readonly size: number;
+    readonly contentType: string;
+}
+
+declare interface GeometryAssetRoot {
+    readonly tenantId: string;
+    readonly worldId: string;
+    readonly layerSetId: string;
+    readonly version: string;
+}
+
+export declare interface GeometryAssetStorageGrantOptions {
+    readonly worlds: ReadonlyArray<AnyWorldDescriptor>;
+    readonly manifest: Context.Service.Shape<typeof GeometryAssetManifestPort>;
+    readonly origin: string;
+    readonly authorize: (request: GeometryAssetReadRequest, subject: Subject) => Effect.Effect<void, GeometryPersistenceError>;
+    readonly expiresInSec?: number;
+    readonly maxAssets?: number;
+    readonly maxManifestBytes?: number;
+    readonly maxAssetBytes?: number;
+}
+
+export declare interface GeometryAssetStorageGrants {
+    grant(request: GeometryAssetReadRequest, subject: Subject): Effect.Effect<GeometryAssetReadGrant, GeometryPersistenceError>;
+}
+
+declare interface GeometryBoxOverlapOptions {
+    readonly maxTests?: number;
+}
+
+declare interface GeometryCellChunk {
+    readonly coordinate: GeometryPreparedCoordinate;
+    readonly ownerCellId: string;
+    readonly writable: boolean;
+}
+
+declare interface GeometryCellCoverage {
+    readonly scope: GeometryPreparedScope;
+    readonly cell: WorldCell;
+    readonly marginChunks: number;
+    readonly chunks: ReadonlyArray<GeometryCellChunk>;
+}
+
+declare interface GeometryCellCoverageOptions {
+    readonly maxChunks?: number | undefined;
+    /** World topology is currently 2D; 3D representations require an explicit
+     * server-authored half-open vertical span in exact global Q16 raw units. */
+    readonly vertical?: {
+        readonly minimumRaw: number;
+        readonly maximumRaw: number;
+    };
+}
+
+declare type GeometryChunk = GeometryTileChunk | GeometryHeightfieldChunk | GeometryShapesChunk | GeometryVoxelChunk;
+
+/** One net codec patch against static revision zero, plus the independent durable mutation revision. */
+export declare const geometryChunkDeltasTable: TableLike;
+
+export declare const geometryChunkHttpHeaders: Readonly<{
+    scope: "x-voltro-geometry-scope";
+    revision: "x-voltro-geometry-revision";
+    contentSha256: "x-voltro-geometry-content-sha256";
+}>;
+
+/** Full scoped caller -> locator query only. Tenant/kind are resolved server-side;
+ * neither this query nor its coordinates grant read rights. */
+export declare const geometryChunkHttpQuery: (offered: GeometryPersistenceScope) => string;
+
+export declare interface GeometryChunkHttpResponse {
+    readonly status: 200;
+    readonly headers: Readonly<Record<string, string>>;
+    readonly body: Uint8Array;
+}
+
+/** Actual authorized SQL/source observation -> native binary HTTP response.
+ * Helper installs no route/authorization/cache policy or second chunk/Delta
+ * format. Caller must select trusted scope and read rights before invoking. */
+export declare const geometryChunkHttpResponse: (offered: GeometryPersistenceObservation, options?: {
+    readonly maxBytes?: number | undefined;
+}) => GeometryChunkHttpResponse;
+
+export declare type GeometryChunkLease = WorldTransitionLease;
+
+export declare type GeometryChunkLeaseOptions = WorldTransitionLeaseOptions;
+
+export declare interface GeometryChunkLeases {
+    readonly tenantId: string;
+    acquire(scope: GeometryPersistenceScope): Effect.Effect<Option_2.Option<GeometryChunkLease>, HotError | ProtocolError>;
+}
+
+declare interface GeometryChunkSnapshot {
+    readonly scope: GeometryPersistenceScope;
+    readonly requestId: string;
+    readonly revision: number;
+    readonly staticBlobSha256: string;
+    readonly staticContentSha256: string;
+    readonly blobSha256: string;
+    readonly contentSha256: string;
+    readonly patchSha256: string;
+    readonly patch: Uint8Array;
+}
+
+declare type GeometryCollisionDerive = (context: GeometryDerivationContext) => GeometryChunk;
+
+export declare interface GeometryCommitCoordinator {
+    commit(input: GeometryPersistenceCommit): Effect.Effect<GeometryPersistenceReceipt, GeometryCommitCoordinatorError>;
+    observation(): GeometryCommitCoordinatorObservation;
+    /** Trusted local writer fence/join only. App privacy also owns actor/session withdrawal. */
+    withdrawSubject(target: GeometryPrivacyTarget): Effect.Effect<void, GeometryCommitCoordinatorError>;
+    /** Confirm actual persistence-port erasure before discarding even unknown local SQL work. */
+    eraseSubject(target: GeometryPrivacyTarget): Effect.Effect<void, GeometryCommitCoordinatorError>;
+    /** Await owned release. An unconfirmed SQL operation remains pending and refuses close until the same request is resolved. */
+    close(): Effect.Effect<void, GeometryCommitCoordinatorError>;
+}
+
+export declare type GeometryCommitCoordinatorError = ProtocolError | BudgetExceeded | HotError;
+
+export declare interface GeometryCommitCoordinatorObservation {
+    readonly pending: number;
+    readonly pendingBytes: number;
+    readonly active: number;
+    readonly retainedReceipts: number;
+    readonly subjectFences: number;
+    readonly closing: boolean;
+    readonly closed: boolean;
+}
+
+export declare interface GeometryCommitCoordinatorOptions {
+    readonly tenantId: string;
+    readonly maxPending?: number | undefined;
+    readonly maxPatchBytes?: number | undefined;
+    readonly maxPendingBytes?: number | undefined;
+    readonly maxSubjectFences?: number;
+}
+
+declare type GeometryCompaction = (context: GeometryCompactionContext) => GeometryPatch;
+
+/** Genuine immutable native artifacts only. Compaction preserves the current
+ * truth; it cannot authorize a different edit, owner, revision or SQL write. */
+declare interface GeometryCompactionContext {
+    readonly static: GeometryArtifact;
+    readonly current: GeometryArtifact;
+    readonly limits: GeometryPatchLimits;
+    readonly codecLimits: GeometryArtifactLimits<GeometryKind>;
+}
+
+declare interface GeometryCompactionStrategies {
+    readonly compaction: GeometryCompaction;
+}
+
+export declare interface GeometryDeltaMigrationFrom {
+    readonly static: GeometryArtifact;
+    readonly current: GeometryArtifact;
+    readonly revision: number;
+}
+
+export declare interface GeometryDeltaMigrationTo {
+    readonly static: GeometryArtifact;
+}
+
+/** Outside-Tick native data only. No query callback, provider, actor, Store or
+ * authority capability is accepted as a derivation result. */
+declare interface GeometryDerivationContext {
+    readonly chunk: GeometryChunk;
+    readonly codecLimits: GeometryArtifactLimits<GeometryKind>;
+}
+
+declare interface GeometryDerivationStrategies {
+    readonly collisionDerive: GeometryCollisionDerive;
+    readonly navDerive: GeometryNavDerive;
+}
+
+export declare interface GeometryDirtyChunkReference {
+    readonly scope: GeometryPersistenceScope;
+    readonly revision: number;
+    readonly blobSha256: string;
+    readonly contentSha256: string;
+}
+
+/** Trusted server snapshot. Never derive these rights, positions, budgets or
+ * catalogs from the intent body. App policy must recheck authority at commit. */
+declare interface GeometryEditAuthority {
+    readonly dynamicEnabled: boolean;
+    readonly ownsChunk: boolean;
+    readonly canBuild: boolean;
+    readonly cooldownReady: boolean;
+    readonly remainingOps: number;
+    readonly maxReachRaw: number;
+    readonly maxHeightUnits: number;
+    readonly position: {
+        readonly xRaw: number;
+        readonly yRaw: number;
+        readonly zRaw: number;
+    };
+    readonly materials: ReadonlyArray<GeometryTileMaterial>;
+    readonly shapes: ReadonlyArray<GeometryShapeTemplate>;
+}
+
+declare interface GeometryEditContext {
+    readonly chunk: GeometryChunk;
+    readonly intent: GeometryEditIntent;
+    readonly authority: GeometryEditAuthority;
+    readonly placementId: string;
+    readonly codecLimits?: GeometryArtifactLimits<GeometryKind> | undefined;
+}
+
+export declare interface GeometryEditIngress {
+    /** Actual native channel receiver only. Captures memory without I/O. */
+    stage(actualSession: unknown, message: unknown): 'queued' | 'retained';
+    /** Outside-Tick subject lookup, native owner queue/SQL/CPU/publication. */
+    pump(): Effect.Effect<ReadonlyArray<GeometryPersistenceReceipt>, GeometryCommitCoordinatorError>;
+    /** Trusted local discard; attempted/uncertain SQL work cannot be removed. */
+    discardUnsubmitted(target: GeometryPrivacyTarget): Effect.Effect<boolean, GeometryCommitCoordinatorError>;
+    /** Local writer fence/join only; actual actor/reader quiescence remains external. */
+    withdrawSubject(target: GeometryPrivacyTarget): Effect.Effect<void, GeometryCommitCoordinatorError>;
+    /** Forget matching memory only after the real owner/SQL/content erase confirms. */
+    eraseSubject(target: GeometryPrivacyTarget): Effect.Effect<void, GeometryCommitCoordinatorError>;
+    /** Fence new identities synchronously before a Host shutdown drain. */
+    fence(): void;
+    close(): Effect.Effect<void, GeometryCommitCoordinatorError>;
+    observation(): {
+        readonly pending: number;
+        readonly active: boolean;
+        readonly closing: boolean;
+        readonly closed: boolean;
+        readonly subjectFences: number;
+    };
+}
+
+export declare interface GeometryEditIngressOptions {
+    readonly scope: GeometryPreparedScope;
+    readonly owner: GeometryPersistenceOwner;
+    /** Actual current server identity lookup. Session evidence does not attest
+     * user/guest kind, so the body and Seat claims cannot supply it. */
+    readonly resolveSubject: (scope: GeometryEditIngressSubjectScope) => Effect.Effect<GeometryPersistenceSubject, GeometryCommitCoordinatorError>;
+    readonly maxPending?: number | undefined;
+    readonly maxPerPump?: number;
+    readonly maxSubjectFences?: number;
+}
+
+export declare interface GeometryEditIngressSubjectScope {
+    readonly tenantId: string;
+    readonly roomId: string;
+    readonly epoch: number;
+    readonly sessionId: string;
+    readonly subjectId: string;
+}
+
+/** Player requests an action and its target, never solidity, shape dimensions,
+ * an authoritative player position, revision, owner, full chunk or Delta bytes. */
+declare type GeometryEditIntent = {
+    readonly op: 'setTile';
+    readonly x: number;
+    readonly y: number;
+    readonly material: string;
+} | {
+    readonly op: 'raiseHeight';
+    readonly x: number;
+    readonly y: number;
+    readonly units: number;
+} | {
+    readonly op: 'setVoxel';
+    readonly x: number;
+    readonly y: number;
+    readonly z: number;
+    readonly material: string;
+} | {
+    readonly op: 'placeShape';
+    readonly template: string;
+    readonly xRaw: number;
+    readonly yRaw: number;
+    readonly zRaw: number;
+} | {
+    readonly op: 'removeShape';
+    readonly id: string;
+};
+
+declare interface GeometryEditStrategies {
+    /** Pure policy slot. Current native Session/SQL ownership and codec integrity cannot be overridden by this slot. */
+    readonly opValidator: (context: GeometryEditContext) => void;
+    /** Pure rule slot; returned chunk is admitted under the original identity/layout/profile. */
+    readonly applyOp: (context: GeometryEditContext) => GeometryChunk;
+}
+
+declare type GeometryGenerator = (context: GeometryProceduralContext) => GeometryChunk;
+
+declare interface GeometryGridRayHit {
+    readonly kind: '2d-tiles' | '3d-voxel';
+    readonly scope: GeometryPersistenceScope;
+    readonly revision: number;
+    readonly cell: {
+        readonly x: number;
+        readonly y: number;
+        readonly z?: number;
+    };
+    /** Exact reduced infimum entry fraction on the offered segment, not a
+     * rounded contact point or a floating-point distance. */
+    readonly fraction: {
+        readonly numerator: number;
+        readonly denominator: number;
+    };
+    readonly visitedCells: number;
+}
+
+declare interface GeometryGridRayOptions {
+    readonly maxVisitedCells?: number;
+}
+
+declare interface GeometryGridSweepHit {
+    readonly kind: '2d-tiles' | '3d-voxel';
+    readonly scope: GeometryPersistenceScope;
+    readonly revision: number;
+    readonly cell: {
+        readonly x: number;
+        readonly y: number;
+        readonly z?: number;
+    };
+    /** Infimum/supremum of positive-volume overlap, clipped to [0,1]. Contact
+     * alone is not an overlap; fractions are exact reduced integer ratios. */
+    readonly entry: FixedSlabFraction;
+    readonly exit: FixedSlabFraction;
+    readonly initialOverlap: boolean;
+    readonly testedCells: number;
+}
+
+/** A half-open raw box `[min, max)` on all three axes; a heightfield box needs its z extent. */
+declare interface GeometryHeightfieldBoxRaw {
+    readonly minXRaw: number;
+    readonly minYRaw: number;
+    readonly minZRaw: number;
+    readonly maxXRaw: number;
+    readonly maxYRaw: number;
+    readonly maxZRaw: number;
+}
+
+declare type GeometryHeightfieldChunk = (typeof GeometryHeightfieldChunkSchema)["Type"];
+
+declare const GeometryHeightfieldChunkSchema: Schema.Struct<{
+    readonly kind: Schema.Literal<"2d-heightfield">;
+    readonly formatVersion: Schema.Literal<1>;
+    readonly address: Schema.Struct<{
+        readonly worldId: Schema.String;
+        readonly layerSetId: Schema.String;
+        readonly cx: Schema.Int;
+        readonly cy: Schema.Int;
+    }>;
+    readonly version: Schema.String;
+    readonly width: Schema.Int;
+    readonly height: Schema.Int;
+    readonly sampleSpacingRaw: Schema.Int;
+    readonly baseHeightRaw: Schema.Int;
+    readonly heightQuantumRaw: Schema.Int;
+    readonly heights: Schema.$Array<Schema.Int>;
+}>;
+
+declare interface GeometryHeightfieldLimits {
+    readonly maxSide: number;
+    readonly maxSamples: number;
+    readonly maxBytes: number;
+}
+
+declare interface GeometryHeightfieldRayHit {
+    readonly kind: '2d-heightfield';
+    readonly scope: GeometryPersistenceScope;
+    readonly revision: number;
+    /** The first point on the segment at or below the surface, in global raw units. */
+    readonly point: GeometryHeightfieldRayPoint;
+    /** Exact reduced position on the offered segment whose raw-grid point is `point`. */
+    readonly fraction: {
+        readonly numerator: number;
+        readonly denominator: number;
+    };
+    readonly visitedSamples: number;
+}
+
+declare interface GeometryHeightfieldRayPoint {
+    readonly xRaw: number;
+    readonly yRaw: number;
+    readonly zRaw: number;
+}
+
+declare interface GeometryHeightfieldSweepHit {
+    readonly kind: '2d-heightfield';
+    /** The first box position along the path that reaches under the surface, on the raw grid. */
+    readonly box: GeometryHeightfieldBoxRaw;
+    /** Exact reduced position of `box` on the path: raw steps along the longest axis over its length. */
+    readonly fraction: {
+        readonly numerator: number;
+        readonly denominator: number;
+    };
+    /** The start box already reaches under the surface (fraction 0). */
+    readonly initialOverlap: boolean;
+    /** Overlap evaluations used, coarse and refining together. */
+    readonly evaluations: number;
+}
+
+declare interface GeometryHeightfieldView {
+    readonly chunk: GeometryHeightfieldChunk;
+    heightAtSample(x: number, y: number): number;
+    heightAtRaw(xRaw: number, yRaw: number): number;
+}
+
+declare interface GeometryHeightRollbackContext {
+    readonly key: string;
+    readonly before: number;
+    readonly after: number;
+    readonly selected: number;
+    readonly target: boolean;
+}
+
+export declare interface GeometryImportedSourceRequest {
+    readonly tenantId: string;
+    readonly version: string;
+    /** Actual application root; no process cwd/default path is inferred. */
+    readonly appRoot: string;
+}
+
+export declare interface GeometryImportPublication {
+    /** Offline proposal only: a digest confirms no Storage claim or SQL publication. */
+    readonly manifest: GeometryVersionReceipt;
+    readonly artifacts: ReadonlyArray<GeometryArtifact>;
+}
+
+export declare interface GeometryImportPublicationOptions {
+    readonly maxChunks?: number | undefined;
+    readonly maxArtifactBytes?: number;
+    readonly maxManifestBytes?: number;
+    readonly codecLimits?: {
+        readonly [K in GeometryKind]?: GeometryArtifactLimits<K>;
+    } | undefined;
+}
+
+export declare interface GeometryJournalArchiveExport {
+    readonly reference: GeometryJournalArchiveReference;
+    readonly patch: Uint8Array;
+}
+
+export declare const geometryJournalArchiveIndexLayer: (service: Context.Service.Shape<typeof GeometryJournalArchiveIndexPort>) => Layer.Layer<GeometryJournalArchiveIndexPort>;
+
+export declare interface GeometryJournalArchiveIndexOptions {
+    readonly archive: Context.Service.Shape<typeof GeometryJournalArchivePort>;
+    readonly epochNow: () => number;
+    readonly authorize: (operation: 'archive' | 'load' | 'export' | 'erase', scope: GeometryPersistenceScope | GeometryPrivacyTarget) => Effect.Effect<void, GeometryPersistenceError>;
+    /** Real app-owned accepted archive readers/writers must join before erasure. */
+    readonly quiesceSubject: (target: GeometryPrivacyTarget) => Effect.Effect<void, GeometryPersistenceError>;
+    readonly maxPatchBytes?: number | undefined;
+    readonly maxPrivacyRows?: number;
+    readonly maxPrivacyBytes?: number;
+}
+
+export declare class GeometryJournalArchiveIndexPort extends GeometryJournalArchiveIndexPort_base {
+}
+
+declare const GeometryJournalArchiveIndexPort_base: Context.ServiceClass<GeometryJournalArchiveIndexPort, "@voltro/GeometryJournalArchiveIndexPort", {
+    archive(scope: GeometryPersistenceScope, requestId: string): Effect.Effect<GeometryJournalArchiveReference, GeometryPersistenceError>;
+    load(scope: GeometryPersistenceScope, requestId: string): Effect.Effect<Uint8Array, GeometryPersistenceError>;
+    exportSubject(target: GeometryPrivacyTarget): Effect.Effect<ReadonlyArray<GeometryJournalArchiveExport>, GeometryPersistenceError>;
+    eraseSubject(target: GeometryPrivacyTarget): Effect.Effect<void, GeometryPersistenceError>;
+}>;
+
+export declare const geometryJournalArchiveIndexPrivacyHooks: (source: Context.Service.Shape<typeof GeometryJournalArchiveIndexPort>) => Readonly<{
+    tables: readonly TableLike[];
+    onExport: (subjectId: string, context: PluginPrivacyHookContext) => Effect.Effect<readonly GeometryJournalArchiveExport[], GeometryPersistenceError, never>;
+    onErase: (subjectId: string, context: PluginPrivacyHookContext) => Effect.Effect<void, GeometryPersistenceError, never>;
+}>;
+
+export declare const geometryJournalArchiveLayer: (source: Context.Service.Shape<typeof GeometryJournalArchivePort>) => Layer.Layer<GeometryJournalArchivePort>;
+
+export declare class GeometryJournalArchivePort extends GeometryJournalArchivePort_base {
+}
+
+declare const GeometryJournalArchivePort_base: Context.ServiceClass<GeometryJournalArchivePort, "@voltro/GeometryJournalArchivePort", {
+    store(receipt: GeometryPersistenceReceipt, patch: Uint8Array): Effect.Effect<GeometryJournalArchiveReference, GeometryPersistenceError>;
+    load(reference: GeometryJournalArchiveReference): Effect.Effect<Uint8Array, GeometryPersistenceError>;
+    release(reference: GeometryJournalArchiveReference): Effect.Effect<void, GeometryPersistenceError>;
+}>;
+
+declare interface GeometryJournalArchiveReference {
+    readonly receipt: GeometryPersistenceReceipt;
+    readonly patchSha256: string;
+    readonly size: number;
+}
+
+/** Durable S3 custody index for original GPD bytes in normal private S2 Storage.
+ * Separate from immutable SQL admission receipts; no payload is pruned here. */
+export declare const geometryJournalArchivesTable: TableLike;
+
+export declare const geometryJournalCompactionLayer: (source: Context.Service.Shape<typeof GeometryJournalCompactionPort>) => Layer.Layer<GeometryJournalCompactionPort>;
+
+export declare interface GeometryJournalCompactionOptions {
+    readonly archive: Context.Service.Shape<typeof GeometryJournalArchiveIndexPort>;
+    readonly authorize: (scope: GeometryPersistenceScope, requestId: string) => Effect.Effect<void, GeometryPersistenceError>;
+    readonly maxPatchBytes?: number | undefined;
+}
+
+export declare class GeometryJournalCompactionPort extends GeometryJournalCompactionPort_base {
+}
+
+declare const GeometryJournalCompactionPort_base: Context.ServiceClass<GeometryJournalCompactionPort, "@voltro/GeometryJournalCompactionPort", {
+    /** Current SQL receipt metadata remains immutable. true means this call moved
+     * its inline body to the already-confirmed indexed original private GPD. */
+    compact(scope: GeometryPersistenceScope, requestId: string): Effect.Effect<boolean, GeometryPersistenceError>;
+}>;
+
+export declare interface GeometryJournalPatchReaderOptions {
+    readonly archive?: Context.Service.Shape<typeof GeometryJournalArchiveIndexPort>;
+    readonly maxPatchBytes?: number | undefined;
+}
+
+export declare interface GeometryJournalRetentionContext {
+    readonly createdAtMs: number;
+    readonly cutoffMs: number;
+}
+
+export declare const geometryJournalRetentionLayer: (source: Context.Service.Shape<typeof GeometryJournalRetentionPort>) => Layer.Layer<GeometryJournalRetentionPort>;
+
+export declare interface GeometryJournalRetentionOptions {
+    readonly compaction: Context.Service.Shape<typeof GeometryJournalCompactionPort>;
+    readonly epochNow: () => number;
+    readonly authorize: (scope: GeometryPersistenceScope, cutoffMs: number) => Effect.Effect<void, GeometryPersistenceError>;
+    readonly keepInlineMs?: number;
+    readonly pageSize?: number;
+    readonly maxMetadataBytes?: number;
+    readonly strategies?: Partial<GeometryJournalRetentionStrategies> | undefined;
+}
+
+export declare interface GeometryJournalRetentionPage {
+    readonly scope: GeometryPersistenceScope;
+    readonly cutoffMs: number;
+    readonly selected: number;
+    readonly compacted: number;
+    readonly alreadyArchived: number;
+    readonly skipped: number;
+    readonly nextAfter: string | null;
+}
+
+export declare class GeometryJournalRetentionPort extends GeometryJournalRetentionPort_base {
+}
+
+declare const GeometryJournalRetentionPort_base: Context.ServiceClass<GeometryJournalRetentionPort, "@voltro/GeometryJournalRetentionPort", {
+    run(request: GeometryJournalRetentionRequest): Effect.Effect<GeometryJournalRetentionPage, GeometryPersistenceError>;
+}>;
+
+export declare interface GeometryJournalRetentionRequest {
+    readonly scope: GeometryPersistenceScope;
+    readonly after?: string | null;
+}
+
+export declare interface GeometryJournalRetentionStrategies {
+    readonly eligible: (context: GeometryJournalRetentionContext) => boolean;
+}
+
+export declare const geometryJournalRetentionSweepLayer: (source: Context.Service.Shape<typeof GeometryJournalRetentionSweepPort>) => Layer.Layer<GeometryJournalRetentionSweepPort>;
+
+export declare interface GeometryJournalRetentionSweepOptions {
+    readonly worlds: ReadonlyArray<AnyWorldDescriptor>;
+    readonly retention: Context.Service.Shape<typeof GeometryJournalRetentionPort>;
+    /** App-wide SQL maintenance authority, required before inventory and every page. */
+    readonly authorize: (payload: GeometryJournalRetentionWorkflowPayload) => Effect.Effect<void, GeometryPersistenceError>;
+    readonly maxScopes?: number;
+    readonly maxMetadataBytes?: number;
+}
+
+export declare class GeometryJournalRetentionSweepPort extends GeometryJournalRetentionSweepPort_base {
+}
+
+declare const GeometryJournalRetentionSweepPort_base: Context.ServiceClass<GeometryJournalRetentionSweepPort, "@voltro/GeometryJournalRetentionSweepPort", {
+    run(payload: GeometryJournalRetentionWorkflowPayload): Effect.Effect<GeometryJournalRetentionWorkflowResult, GeometryPersistenceError>;
+}>;
+
+/** Ordinary durable activity journals confirmed results. A failed/unknown SQL
+ * sweep never fabricates aggregate progress; retry rereads authoritative SQL. */
+export declare const geometryJournalRetentionWorkflowExecutor: (offered: GeometryJournalRetentionWorkflowPayload) => Effect.Effect<{
+    readonly scopes: number;
+    readonly pages: number;
+    readonly selected: number;
+    readonly compacted: number;
+    readonly alreadyArchived: number;
+    readonly skipped: number;
+}, ProtocolError | BudgetExceeded, WorkflowEngine | WorkflowInstance | GeometryJournalRetentionSweepPort>;
+
+/** Browser-safe workflow control/results; no patch, Subject or credentials. */
+export declare const GeometryJournalRetentionWorkflowPayload: Schema.Struct<{
+    readonly runKey: Schema.NonEmptyString;
+    readonly maxPages: Schema.Int;
+}>;
+
+export declare type GeometryJournalRetentionWorkflowPayload = typeof GeometryJournalRetentionWorkflowPayload.Type;
+
+export declare const GeometryJournalRetentionWorkflowResult: Schema.Struct<{
+    readonly scopes: Schema.Int;
+    readonly pages: Schema.Int;
+    readonly selected: Schema.Int;
+    readonly compacted: Schema.Int;
+    readonly alreadyArchived: Schema.Int;
+    readonly skipped: Schema.Int;
+}>;
+
+export declare type GeometryJournalRetentionWorkflowResult = typeof GeometryJournalRetentionWorkflowResult.Type;
+
+export declare interface GeometryJournalStorageOptions {
+    readonly bucket: string;
+    readonly metadata: Pick<StorageObjectMetadata, 'lookup'>;
+    readonly destination?: string;
+    readonly maxPatchBytes?: number | undefined;
+    readonly maxBodyParts?: number;
+    /** Actual current SQL journal/retirement and tenant permissions. A native
+     * receipt/checksum/Storage reference alone grants no archive authority. */
+    readonly authorize: (operation: 'store' | 'load' | 'release', reference: GeometryJournalArchiveReference) => Effect.Effect<void, GeometryPersistenceError>;
+}
+
+/** Durable idempotency receipts are not an ephemeral optional audit log. No pruning of unresolved receipts. */
+export declare const geometryJournalTable: TableLike;
+
+declare type GeometryKind = GeometryChunk['kind'];
+
+export declare const geometryManifestLayer: (service: Context.Service.Shape<typeof GeometryManifestPort>) => Layer.Layer<GeometryManifestPort>;
+
+/** Outside-Tick actual source metadata. Scope/hash possession grants no rights. */
+export declare class GeometryManifestPort extends GeometryManifestPort_base {
+}
+
+declare const GeometryManifestPort_base: Context.ServiceClass<GeometryManifestPort, "@voltro/GeometryManifestPort", {
+    observe(scope: GeometryPreparedScope): Effect.Effect<GeometryStreamManifest, GeometryPersistenceError>;
+}>;
+
+export declare interface GeometryManifestPublicationOptions {
+    readonly scope: GeometryPreparedScope;
+    readonly owner: GeometryPersistenceOwner;
+    readonly source: Context.Service.Shape<typeof GeometryManifestPort>;
+    readonly currentSessions: () => ReadonlyArray<unknown>;
+    readonly authorizeRecipient: (recipient: GeometryPublicationRecipient, scope: GeometryPreparedScope) => Effect.Effect<void, GeometryPersistenceError>;
+    readonly authorizeChunk: (recipient: GeometryPublicationRecipient, scope: GeometryPersistenceScope) => Effect.Effect<void, GeometryPersistenceError>;
+    readonly channel?: string | undefined;
+    readonly maxRecipients?: number;
+    readonly maxManifestChunks?: number | undefined;
+    readonly maxManifestBytes?: number;
+    readonly maxFragmentDeliveries?: number;
+}
+
+export declare interface GeometryManifestStoreOptions {
+    /** Actual server root/chunk read capabilities; outer player routing must also
+     * resolve current Subject and recipient visibility, not trust offered scope. */
+    readonly authorizeRoot: (scope: GeometryPreparedScope) => Effect.Effect<void, GeometryPersistenceError>;
+    readonly authorizeChunk: (scope: GeometryPersistenceScope) => Effect.Effect<void, GeometryPersistenceError>;
+    readonly maxManifestChunks?: number | undefined;
+    readonly maxManifestBytes?: number;
+}
+
+/** Pure native data rule only; no SQL, actor, journal, permission or Subject. */
+export declare type GeometryMigrateDelta = (from: GeometryDeltaMigrationFrom, to: GeometryDeltaMigrationTo) => GeometryChunk | null;
+
+/** Explicit schema/privacy contribution for composition by the actual Rooms
+ * provider. It neither installs a second plugin nor invents privacy mappings. */
+export declare const geometryMigrationContribution: (offered: Context.Service.Shape<typeof GeometryVersionMigrationPort>) => Pick<VoltroPlugin, "extendSchema" | "subjectPrivacy" | "onErase" | "onExport">;
+
+export declare interface GeometryMigrationReceipt {
+    readonly requestKey: string;
+    readonly inputSha256: string;
+    readonly from: GeometryPersistenceScope;
+    readonly to: GeometryPersistenceScope;
+    readonly fromRevision: number;
+    readonly revision: number;
+    readonly decision: 'kept' | 'discarded' | 'custom';
+    readonly staticChanged: boolean;
+    readonly fromManifestSha256: string;
+    readonly toManifestSha256: string;
+    readonly blobSha256: string;
+    readonly contentSha256: string;
+}
+
+export declare interface GeometryMigrationRequest {
+    readonly from: GeometryPersistenceScope;
+    readonly to: GeometryPersistenceScope;
+    readonly expectedRevision: number;
+    readonly owner: GeometryPersistenceOwner;
+    readonly requestId: string;
+}
+
+/** No Subject identity, native content/patch, owner, raw request or policy source.
+ * Durable metadata retains source/target links for cutover/rebuild/retention. */
+export declare const geometryMigrationsTable: TableLike;
+
+export declare interface GeometryMigrationStoreOptions {
+    readonly strategies?: GeometryVersionPreparationStrategies | undefined;
+    /** Actual app-owned lineage/privacy mapping, authorization and physical work.
+     * Required, durable and idempotent by target.requestId; coordinated callers may
+     * repeat after-fence work. No none-data assumption or successful fallback. */
+    readonly privacy: {
+        exportSubject(target: GeometryPrivacyTarget): Effect.Effect<ReadonlyArray<GeometryMigrationReceipt>, GeometryPersistenceError>;
+        eraseSubject(target: GeometryPrivacyTarget): Effect.Effect<void, GeometryPersistenceError>;
+    };
+    readonly maxPrivacyRows?: number;
+    readonly maxPrivacyBytes?: number;
+    readonly persistence: GeometrySnapshotPreparationOptions['persistence'];
+    readonly staticSource: GeometrySnapshotPreparationOptions['staticSource'];
+    /** Current trusted administrative operation, both scopes and owner. This is
+     * never installed as a player route or a successful default policy. */
+    readonly authorize: (request: GeometryMigrationRequest) => Effect.Effect<void, GeometryPersistenceError>;
+    readonly epochNow: () => number;
+    readonly maxManifestChunks?: number | undefined;
+    readonly maxManifestBytes?: number;
+    readonly maxPatchBytes?: number | undefined;
+    readonly maxAccountedBytes?: number;
+}
+
+declare type GeometryNavDerive = (context: GeometryDerivationContext) => GeometryTileChunk | null;
+
+declare interface GeometryPatch {
+    readonly metadata: GeometryPatchMetadata;
+    bytes(): Uint8Array;
+}
+
+declare interface GeometryPatchLimits {
+    readonly maxBytes: number;
+    readonly maxMetadataBytes: number;
+}
+
+declare type GeometryPatchMetadata = (typeof GeometryPatchMetadataSchema)["Type"];
+
+declare const GeometryPatchMetadataSchema: Schema.Struct<{
+    readonly kind: Schema.Literals<readonly ["2d-tiles", "2d-heightfield", "3d-shapes", "3d-voxel"]>;
+    readonly formatVersion: Schema.Literal<1>;
+    readonly worldId: Schema.String;
+    readonly layerSetId: Schema.String;
+    readonly cx: Schema.Int;
+    readonly cy: Schema.Int;
+    readonly cz: Schema.optional<Schema.Int>;
+    readonly version: Schema.String;
+    readonly baseRevision: Schema.Int;
+    readonly revision: Schema.Int;
+    readonly baseBlobSha256: Schema.String;
+    readonly blobSha256: Schema.String;
+    readonly baseContentSha256: Schema.String;
+    readonly contentSha256: Schema.String;
+    readonly changed: Schema.Boolean;
+    readonly stateSchemaHash: Schema.Int;
+}>;
+
+export declare interface GeometryPersistenceCommit {
+    readonly scope: GeometryPersistenceScope;
+    readonly owner: GeometryPersistenceOwner;
+    readonly subject: GeometryPersistenceSubject;
+    readonly requestId: string;
+    readonly patch: Uint8Array;
+    /** Server-owned genuine RoomServerSession only; never accepted from a wire payload. */
+    readonly actualSession?: unknown;
+}
+
+export declare type GeometryPersistenceError = ProtocolError | BudgetExceeded;
+
+/** The same Tag is used for a real SQL service or an explicit application/test replacement. */
+export declare const geometryPersistenceLayer: (service: Context.Service.Shape<typeof GeometryPersistencePort>) => Layer.Layer<GeometryPersistencePort>;
+
+export declare interface GeometryPersistenceObservation {
+    readonly scope: GeometryPersistenceScope;
+    readonly revision: number;
+    readonly artifact: GeometryArtifact;
+}
+
+export declare type GeometryPersistenceOperation = 'publish' | 'observe' | 'commit' | 'export' | 'erase';
+
+export declare interface GeometryPersistenceOwner {
+    readonly roomId: string;
+    readonly hostId: string;
+    readonly epoch: number;
+}
+
+/** Outside-Tick trusted service. A commit receipt confirms SQL only, not delivery or actor activation. */
+export declare class GeometryPersistencePort extends GeometryPersistencePort_base {
+}
+
+declare const GeometryPersistencePort_base: Context.ServiceClass<GeometryPersistencePort, "@voltro/GeometryPersistencePort", {
+    publish(input: GeometryVersionPublication): Effect.Effect<GeometryVersionReceipt, GeometryPersistenceError>;
+    observe(scope: GeometryPersistenceScope): Effect.Effect<GeometryPersistenceObservation, GeometryPersistenceError>;
+    commit(input: GeometryPersistenceCommit): Effect.Effect<GeometryPersistenceReceipt, GeometryPersistenceError>;
+    exportSubject(target: GeometryPrivacyTarget): Effect.Effect<ReadonlyArray<GeometrySubjectOperation>, GeometryPersistenceError>;
+    eraseSubject(target: GeometryPrivacyTarget): Effect.Effect<void, GeometryPersistenceError>;
+}>;
+
+/** Explicit hooks for the enclosing Rooms privacy lifetime. They do not install themselves or invent an erasure policy. */
+export declare const geometryPersistencePrivacyHooks: (source: Context.Service.Shape<typeof GeometryPersistencePort>) => Readonly<{
+    tables: readonly TableLike[];
+    onErase: (subjectId: string, context: PluginPrivacyHookContext) => Effect.Effect<void, GeometryPersistenceError>;
+    onExport: (subjectId: string, context: PluginPrivacyHookContext) => Effect.Effect<ReadonlyArray<GeometrySubjectOperation>, GeometryPersistenceError>;
+}>;
+
+export declare interface GeometryPersistenceReceipt {
+    readonly scope: GeometryPersistenceScope;
+    readonly requestId: string;
+    readonly baseRevision: number;
+    readonly revision: number;
+    readonly changed: boolean;
+    readonly blobSha256: string;
+    readonly contentSha256: string;
+}
+
+export declare interface GeometryPersistenceScope {
+    readonly tenantId: string;
+    readonly kind: GeometryKind;
+    readonly worldId: string;
+    readonly version: string;
+    readonly layerSetId: string;
+    readonly cx: number;
+    readonly cy: number;
+    readonly cz?: number | undefined;
+}
+
+export declare interface GeometryPersistenceStoreOptions {
+    /** Select World compaction rules for fresh commits. Historical reads and
+     * confirmed receipt replay keep their original native data semantics. */
+    readonly worlds?: ReadonlyArray<AnyWorldDescriptor> | undefined;
+    readonly strategies?: Partial<GeometryCompactionStrategies> | undefined;
+    readonly staticSource: Context.Service.Shape<typeof GeometryStaticSourcePort>;
+    readonly epochNow: () => number;
+    /** Must authorize the actual World/layer/chunk and server operation, not merely accept a claimed room ID. */
+    readonly authorize: (operation: GeometryPersistenceOperation, scope: GeometryPersistenceScope | GeometryVersionReceipt | GeometryPrivacyTarget, context?: {
+        readonly owner: GeometryPersistenceOwner;
+        readonly subject: GeometryPersistenceCommit['subject'];
+        readonly requestId: string;
+    }) => Effect.Effect<void, GeometryPersistenceError>;
+    /** Both must be durable/idempotent by target.requestId. Erasure first requires the ordinary Rooms subject fence. */
+    readonly quiesceSubject: (target: GeometryPrivacyTarget) => Effect.Effect<void, GeometryPersistenceError>;
+    readonly eraseSubjectContent: (target: GeometryPrivacyTarget) => Effect.Effect<void, GeometryPersistenceError>;
+    /** Player-facing installations require a genuine current Session + locked SQL seat.
+     * Omit only for explicitly trusted server authors; authorize still owns Subject.kind/rights. */
+    readonly requirePlayerSession?: boolean;
+    readonly journalArchiveIndex?: Context.Service.Shape<typeof GeometryJournalArchiveIndexPort>;
+    readonly codecLimits?: {
+        readonly [K in GeometryKind]?: GeometryArtifactLimits<K>;
+    } | undefined;
+    readonly maxManifestChunks?: number | undefined;
+    readonly maxManifestBytes?: number;
+    readonly maxDeltaBytes?: number;
+    readonly maxReceiptsPerChunk?: number;
+    readonly maxPrivacyRows?: number;
+    readonly maxPrivacyBytes?: number;
+}
+
+export declare interface GeometryPersistenceSubject {
+    readonly id: string;
+    readonly kind: 'user' | 'guest';
+}
+
+export declare const geometryPersistenceTables: readonly TableLike[];
+
+export declare interface GeometryPlayerEditOwner {
+    /** Server channel/lifecycle staging only, outside Tick. Never accepts player authority facts. `'rejected'`: this
+     * exact request was refused by the current policy or validator before any commit was prepared. */
+    queue(request: GeometryPlayerEditRequest): 'queued' | 'retained' | 'rejected';
+    /** Whether this request was refused before preparation (bounded memory of recent refusals). */
+    rejected(requestId: string): boolean;
+    /** Serial awaited policy/preparation/SQL/CPU/publication, no autonomous timer or retry loop. */
+    pump(): Effect.Effect<ReadonlyArray<GeometryPersistenceReceipt>, GeometryCommitCoordinatorError>;
+    /** Trusted server local discard only, before this owner prepared any commit.
+     * false means local absence, never proof of global rejection/no SQL work. */
+    discardUnsubmitted(target: GeometryPrivacyTarget): Effect.Effect<boolean, GeometryCommitCoordinatorError>;
+    withdrawSubject(target: GeometryPrivacyTarget): Effect.Effect<void, GeometryCommitCoordinatorError>;
+    eraseSubject(target: GeometryPrivacyTarget): Effect.Effect<void, GeometryCommitCoordinatorError>;
+    close(): Effect.Effect<void, GeometryCommitCoordinatorError>;
+    observation(): GeometryPlayerEditOwnerObservation;
+}
+
+export declare interface GeometryPlayerEditOwnerObservation {
+    readonly pending: number;
+    readonly prepared: number;
+    readonly pendingPatchBytes: number;
+    readonly active: boolean;
+    readonly subjectWindows: number;
+    readonly subjectFences: number;
+    readonly closing: boolean;
+    readonly closed: boolean;
+}
+
+export declare interface GeometryPlayerEditOwnerOptions {
+    readonly tenantId: string;
+    readonly now: () => number;
+    readonly authorizeIntent: (request: GeometryPlayerEditPolicyRequest) => Effect.Effect<GeometryEditAuthority, GeometryCommitCoordinatorError>;
+    /** Await an actual publication capability; void confirms this handoff only, never remote application ACK. */
+    readonly publishCommitted: (publication: GeometryPlayerEditPublication) => Effect.Effect<void, GeometryCommitCoordinatorError>;
+    readonly strategies?: Partial<GeometryEditStrategies> | undefined;
+    readonly maxPending?: number | undefined;
+    readonly maxPendingPatchBytes?: number;
+    readonly maxOpsPerPump?: number;
+    readonly maxSubjectWindows?: number;
+    readonly maxSubjectFences?: number;
+    readonly localWindowMs?: number;
+    readonly localOpsPerWindow?: number;
+    readonly localCooldownMs?: number;
+}
+
+export declare interface GeometryPlayerEditPolicyRequest extends GeometryPlayerEditRequest {
+    readonly scope: GeometryPersistenceScope;
+    /** Exact request authority/reservation must remain idempotent across an unknown result. */
+    readonly phase: 'prepare' | 'retry';
+    /** Host Room mutations: the editing player's committed World point (its World entity through
+     * `world.movement.position`), read at this authorization; null when the Room has no such point. */
+    readonly editor?: {
+        readonly position: GeometryEditAuthority['position'];
+    } | null;
+}
+
+export declare interface GeometryPlayerEditPublication {
+    readonly scope: GeometryPersistenceScope;
+    readonly requestId: string;
+    readonly intent: GeometryEditIntent;
+    readonly receipt: GeometryPersistenceReceipt;
+    readonly patch: Uint8Array;
+}
+
+export declare interface GeometryPlayerEditRequest {
+    readonly coordinate: GeometryPreparedCoordinate;
+    readonly owner: GeometryPersistenceOwner;
+    readonly subject: GeometryPersistenceSubject;
+    readonly requestId: string;
+    readonly intent: GeometryEditIntent;
+    /** Server-selected actual native Session; never a player body field. */
+    readonly actualSession: unknown;
+}
+
+export declare interface GeometryPngImportOptions {
+    readonly worldId: string;
+    readonly layerSetId: string;
+    readonly version: string;
+    readonly origin: {
+        readonly cx: number;
+        readonly cy: number;
+    };
+    /** A chunk owns cellsPerChunk + 1 samples, sharing the border with its neighbor. */
+    readonly cellsPerChunk?: number;
+    readonly sampleSpacingRaw?: number;
+    readonly baseHeightRaw: number;
+    readonly heightQuantumRaw: number;
+    /** The unsigned image sample that represents baseHeightRaw. No implicit sea level. */
+    readonly sampleZero: number;
+    readonly maxInputBytes?: number;
+    readonly maxSamples?: number | undefined;
+    readonly maxChunks?: number | undefined;
+    readonly maxPngChunks?: number;
+    readonly codecLimits?: Partial<GeometryHeightfieldLimits> | undefined;
+}
+
+declare interface GeometryPointRaw3D {
+    readonly xRaw: number;
+    readonly yRaw: number;
+    readonly zRaw: number;
+}
+
+export declare interface GeometryPreparedCell {
+    readonly coverage: GeometryCellCoverage;
+    readonly inventory: GeometryPreparedInventory;
+}
+
+export declare interface GeometryPreparedCellLoadOptions extends GeometryPreparedLoadOptions {
+    readonly vertical?: GeometryCellCoverageOptions['vertical'];
+}
+
+declare interface GeometryPreparedCoordinate {
+    readonly cx: number;
+    readonly cy: number;
+    readonly cz?: number | undefined;
+}
+
+declare type GeometryPreparedEntry = PreparedCommon & GeometryPreparedView & {
+    /** Independently prepared native collision data. Original view/artifact remains the edit/rebuild baseline. */
+    readonly collision: GeometryPreparedView;
+    readonly navigation: GeometryTileView | null;
+};
+
+declare interface GeometryPreparedInventory {
+    readonly scope: GeometryPreparedScope;
+    readonly entries: ReadonlyArray<GeometryPreparedEntry>;
+    readonly accountedBytes: number;
+    /** CPU-only lookup; absence is explicit, never an empty collision chunk. */
+    at(coordinate: GeometryPreparedCoordinate): GeometryPreparedEntry;
+    contains(coordinate: GeometryPreparedCoordinate): boolean;
+}
+
+export declare interface GeometryPreparedLoadOptions extends GeometryPreparedOptions {
+    readonly maxConcurrent?: number | undefined;
+}
+
+declare interface GeometryPreparedOptions {
+    readonly strategies?: Partial<GeometryDerivationStrategies> | undefined;
+    readonly navEnabled?: boolean;
+    readonly maxChunks?: number | undefined;
+    readonly maxAccountedBytes?: number;
+    readonly codecLimits?: {
+        readonly [K in GeometryKind]?: GeometryArtifactLimits<K>;
+    } | undefined;
+}
+
+declare interface GeometryPreparedScope {
+    readonly tenantId: string;
+    readonly kind: GeometryKind;
+    readonly worldId: string;
+    readonly layerSetId: string;
+    readonly version: string;
+}
+
+/** Native prepared data only. Caller must confirm both published manifests,
+ * frozen source revision/owner, real idempotent migration journal and atomic SQL
+ * installation before actor/client activation. This is never that receipt. */
+export declare interface GeometryPreparedVersionMigration {
+    readonly fromScope: GeometryPersistenceScope;
+    readonly scope: GeometryPersistenceScope;
+    readonly fromRevision: number;
+    readonly staticChanged: boolean;
+    readonly decision: 'kept' | 'discarded' | 'custom';
+    readonly artifact: GeometryArtifact;
+    readonly patch: GeometryPatch;
+}
+
+declare type GeometryPreparedView = ({
+    readonly kind: '2d-tiles';
+    readonly view: GeometryTileView;
+} | {
+    readonly kind: '2d-heightfield';
+    readonly view: GeometryHeightfieldView;
+} | {
+    readonly kind: '3d-shapes';
+    readonly view: GeometryShapesView;
+} | {
+    readonly kind: '3d-voxel';
+    readonly view: GeometryVoxelView;
+});
+
+export declare interface GeometryPrivacyTarget {
+    readonly tenantId: string;
+    readonly subject: GeometryPersistenceSubject;
+    readonly requestId: string;
+}
+
+declare interface GeometryProceduralContext {
+    readonly seed: number;
+    readonly kind: GeometryKind;
+    readonly address: GeometryChunk['address'];
+    readonly version: string;
+}
+
+export declare interface GeometryProceduralPublicationOptions extends Omit<GeometryImportPublicationOptions, 'codecLimits'> {
+    readonly maxWorkers?: number;
+}
+
+export declare interface GeometryProceduralWorker {
+    /** One accepted job at a time; caller owns full-version Storage/SQL publication. */
+    generate(scope: GeometryPersistenceScope): Effect.Effect<GeometryArtifact, GeometryPersistenceError>;
+    /** Waits admitted generation, then actual native termination/exit. */
+    close(): Effect.Effect<void, GeometryPersistenceError>;
+    observe(): GeometryProceduralWorkerObservation;
+}
+
+export declare interface GeometryProceduralWorkerObservation {
+    readonly phase: 'ready' | 'busy' | 'closing' | 'closed' | 'failed';
+    readonly completedJobs: number;
+    /** Only the actual native Worker exit event supplies this number. */
+    readonly exitCode: number | null;
+}
+
+export declare interface GeometryProceduralWorkerOptions {
+    /** Explicit compiled app module exporting the same genuine World declaration. */
+    readonly worldModuleUrl: string;
+    /** Optional explicit installed development loader; never inherited implicitly. */
+    readonly moduleLoaderUrl?: string;
+    readonly exportName?: string;
+    readonly timeoutMs?: number;
+    readonly maxArtifactBytes?: number;
+    readonly maxOldGenerationMb?: number;
+    readonly codecLimits?: GeometryImportPublicationOptions['codecLimits'] | undefined;
+}
+
+export declare interface GeometryPublicationRecipient {
+    readonly tenantId: string;
+    readonly roomId: string;
+    readonly sessionId: string;
+    readonly subjectId: string;
+    readonly epoch: number;
+}
+
+export declare interface GeometryReliablePublicationOptions {
+    readonly scope: GeometryPreparedScope;
+    readonly owner: GeometryPersistenceOwner;
+    readonly currentSessions: () => ReadonlyArray<unknown>;
+    /** Actual current World/layer/chunk read/view rights, outside Tick. Native identity is necessary, not sufficient. */
+    readonly authorizeRecipient: (recipient: GeometryPublicationRecipient, scope: GeometryPersistenceScope) => Effect.Effect<void, GeometryCommitCoordinatorError>;
+    readonly channel?: string | undefined;
+    readonly maxRecipients?: number;
+    readonly maxPatchBytes?: number | undefined;
+    readonly maxFragmentDeliveries?: number;
+}
+
+export declare interface GeometryRollbackCoordinator {
+    rollback(request: GeometryRollbackExecution): Effect.Effect<GeometryPersistenceReceipt, GeometryCommitCoordinatorError>;
+    prepareActivation(actor: GeometryActorInventory, request: GeometryRollbackExecution): Effect.Effect<GeometryActivation, GeometryCommitCoordinatorError>;
+    withdrawSubject(target: GeometryPrivacyTarget): Effect.Effect<void, GeometryCommitCoordinatorError>;
+    close(): Effect.Effect<void, GeometryCommitCoordinatorError>;
+    observation(): GeometryRollbackCoordinatorObservation;
+}
+
+export declare interface GeometryRollbackCoordinatorObservation {
+    readonly jobs: number;
+    readonly active: number;
+    readonly patchBytes: number;
+    readonly unconfirmed: number;
+    readonly subjectFences: number;
+    readonly closing: boolean;
+    readonly closed: boolean;
+}
+
+export declare interface GeometryRollbackCoordinatorOptions {
+    readonly tenantId: string;
+    readonly authorize: (request: GeometryRollbackExecution) => Effect.Effect<void, GeometryCommitCoordinatorError>;
+    readonly maxJobs?: number;
+    readonly maxPatchBytes?: number | undefined;
+    readonly maxPendingBytes?: number | undefined;
+    readonly maxSubjectFences?: number;
+}
+
+export declare interface GeometryRollbackExecution extends GeometryRollbackRequest {
+    readonly requestId: string;
+}
+
+declare interface GeometryRollbackOptions {
+    readonly maxEntries?: number;
+    readonly maxJournalBytes?: number;
+    readonly maxCells?: number | undefined;
+    readonly maxComparedCells?: number;
+    readonly codecLimits?: GeometryArtifactLimits<GeometryKind> | undefined;
+    readonly strategies?: Partial<GeometryRollbackStrategies> | undefined;
+}
+
+declare interface GeometryRollbackPreparation {
+    readonly artifact: GeometryArtifact;
+    readonly patch: GeometryPatch;
+    readonly revision: number;
+    readonly entries: number;
+    readonly targetEntries: number;
+    readonly restoredCells: number;
+}
+
+export declare const geometryRollbackPreparationLayer: (source: Context.Service.Shape<typeof GeometryRollbackPreparationPort>) => Layer.Layer<GeometryRollbackPreparationPort>;
+
+export declare class GeometryRollbackPreparationPort extends GeometryRollbackPreparationPort_base {
+}
+
+declare const GeometryRollbackPreparationPort_base: Context.ServiceClass<GeometryRollbackPreparationPort, "@voltro/GeometryRollbackPreparationPort", {
+    prepare(request: GeometryRollbackRequest): Effect.Effect<GeometryRollbackPreparation, GeometryPersistenceError>;
+}>;
+
+export declare interface GeometryRollbackRequest {
+    readonly scope: GeometryPersistenceScope;
+    readonly owner: GeometryPersistenceOwner;
+    /** `null`: every actor's changes are undone (reset to the static baseline). */
+    readonly subject: GeometryPersistenceSubject;
+    readonly target: GeometryPersistenceSubject | null;
+}
+
+export declare interface GeometryRollbackStoreOptions {
+    readonly persistence: Context.Service.Shape<typeof GeometryPersistencePort>;
+    readonly staticSource: Context.Service.Shape<typeof GeometryStaticSourcePort>;
+    readonly authorize: (request: GeometryRollbackRequest) => Effect.Effect<void, GeometryPersistenceError>;
+    readonly preparation?: GeometryRollbackOptions;
+    readonly journalArchiveIndex?: Context.Service.Shape<typeof GeometryJournalArchiveIndexPort>;
+    readonly maxEntries?: number;
+    readonly maxJournalBytes?: number;
+    readonly maxManifestChunks?: number | undefined;
+    readonly maxManifestBytes?: number;
+}
+
+declare interface GeometryRollbackStrategies {
+    /** Pure quantized contribution rule. Native layout/codec admission and
+     * current SQL/admin authority remain outside this replaceable slot. */
+    readonly rebaseHeight: (context: GeometryHeightRollbackContext) => number;
+}
+
+declare type GeometryShape = (typeof GeometryShapeSchema)["Type"];
+
+declare interface GeometryShapeRayHit {
+    readonly kind: '3d-shapes';
+    readonly scope: GeometryPersistenceScope;
+    readonly revision: number;
+    /** Native LOCAL shape; scope identifies its owning chunk. */
+    readonly shape: GeometryShape;
+    /** Encloses the exact infimum entry time; width <= 2^-52. Presentation only.
+     * Selection and ownership decisions never use these rounded bounds. */
+    readonly fractionBounds: {
+        readonly lower: number;
+        readonly upper: number;
+    };
+    readonly visitedChunks: number;
+    readonly testedShapes: number;
+}
+
+declare const GeometryShapeSchema: Schema.Union<readonly [Schema.Struct<{
+    readonly halfXRaw: Schema.Int;
+    readonly halfYRaw: Schema.Int;
+    readonly halfZRaw: Schema.Int;
+    readonly id: Schema.String;
+    readonly xRaw: Schema.Int;
+    readonly yRaw: Schema.Int;
+    readonly zRaw: Schema.Int;
+    readonly kind: Schema.Literal<"aabb">;
+}>, Schema.Struct<{
+    readonly radiusRaw: Schema.Int;
+    readonly id: Schema.String;
+    readonly xRaw: Schema.Int;
+    readonly yRaw: Schema.Int;
+    readonly zRaw: Schema.Int;
+    readonly kind: Schema.Literal<"sphere">;
+}>]>;
+
+declare type GeometryShapesChunk = (typeof GeometryShapesChunkSchema)["Type"];
+
+declare const GeometryShapesChunkSchema: Schema.Struct<{
+    readonly kind: Schema.Literal<"3d-shapes">;
+    readonly formatVersion: Schema.Literal<1>;
+    readonly address: Schema.Struct<{
+        readonly worldId: Schema.String;
+        readonly layerSetId: Schema.String;
+        readonly cx: Schema.Int;
+        readonly cy: Schema.Int;
+        readonly cz: Schema.Int;
+    }>;
+    readonly version: Schema.String;
+    readonly extentXRaw: Schema.Int;
+    readonly extentYRaw: Schema.Int;
+    readonly extentZRaw: Schema.Int;
+    readonly shapes: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+        readonly halfXRaw: Schema.Int;
+        readonly halfYRaw: Schema.Int;
+        readonly halfZRaw: Schema.Int;
+        readonly id: Schema.String;
+        readonly xRaw: Schema.Int;
+        readonly yRaw: Schema.Int;
+        readonly zRaw: Schema.Int;
+        readonly kind: Schema.Literal<"aabb">;
+    }>, Schema.Struct<{
+        readonly radiusRaw: Schema.Int;
+        readonly id: Schema.String;
+        readonly xRaw: Schema.Int;
+        readonly yRaw: Schema.Int;
+        readonly zRaw: Schema.Int;
+        readonly kind: Schema.Literal<"sphere">;
+    }>]>>;
+}>;
+
+declare interface GeometryShapesLimits {
+    readonly maxShapes: number;
+    readonly maxBytes: number;
+}
+
+declare interface GeometryShapesView {
+    readonly chunk: GeometryShapesChunk;
+    containingRaw(point: GeometryPointRaw3D, maximumShapes?: number): ReadonlyArray<GeometryShape>;
+    /** Closed LOCAL segment and native volumes. Canonical ID order, not distance
+     * order; no first-hit fraction or cross-chunk ownership is implied. */
+    intersectingSegmentRaw(from: GeometryPointRaw3D, to: GeometryPointRaw3D, maximumShapes?: number): ReadonlyArray<GeometryShape>;
+}
+
+declare type GeometryShapeTemplate = {
+    readonly key: string;
+    readonly kind: 'aabb';
+    readonly halfXRaw: number;
+    readonly halfYRaw: number;
+    readonly halfZRaw: number;
+} | {
+    readonly key: string;
+    readonly kind: 'sphere';
+    readonly radiusRaw: number;
+};
+
+export declare interface GeometrySnapshotPreparationOptions {
+    readonly manifest: Context.Service.Shape<typeof GeometryManifestPort>;
+    readonly persistence: Context.Service.Shape<typeof GeometryPersistencePort>;
+    readonly staticSource: Context.Service.Shape<typeof GeometryStaticSourcePort>;
+    /** Actual current recipient/World/layer/chunk admission from trusted server. */
+    readonly authorize: (scope: GeometryPersistenceScope) => Effect.Effect<void, GeometryPersistenceError>;
+    readonly maxManifestChunks?: number | undefined;
+    readonly maxManifestBytes?: number;
+    readonly maxPatchBytes?: number | undefined;
+    readonly codecLimits?: {
+        readonly [K in GeometryKind]?: GeometryArtifactLimits<K>;
+    } | undefined;
+}
+
+declare type GeometrySource = {
+    readonly _tag: 'GeometrySource';
+    readonly kind: 'cms';
+    readonly key: string;
+    readonly channel: string;
+} | {
+    readonly _tag: 'GeometrySource';
+    readonly kind: 'imported';
+    readonly directory: string;
+} | {
+    readonly _tag: 'GeometrySource';
+    readonly kind: 'procedural';
+    readonly seed: number;
+    readonly generator: GeometryGenerator;
+};
+
+/** Actual current scoped read URL; identity/digest is never a grant. */
+export declare class GeometryStaticReadGrantPort extends GeometryStaticReadGrantPort_base {
+}
+
+declare const GeometryStaticReadGrantPort_base: Context.ServiceClass<GeometryStaticReadGrantPort, "@voltro/GeometryStaticReadGrantPort", {
+    grant(scope: GeometryPersistenceScope, subject: Subject): Effect.Effect<string, GeometryPersistenceError>;
+}>;
+
+export declare interface GeometryStaticReference extends GeometryPersistenceScope {
+    readonly blobSha256: string;
+    readonly contentSha256: string;
+}
+
+export declare const geometryStaticSourceLayer: (service: Context.Service.Shape<typeof GeometryStaticSourcePort>) => Layer.Layer<GeometryStaticSourcePort>;
+
+/** Trusted immutable blob source. Neither this Tag nor a digest authorizes publishing a manifest. */
+export declare class GeometryStaticSourcePort extends GeometryStaticSourcePort_base {
+}
+
+declare const GeometryStaticSourcePort_base: Context.ServiceClass<GeometryStaticSourcePort, "@voltro/GeometryStaticSourcePort", {
+    load(reference: GeometryStaticReference): Effect.Effect<Uint8Array, GeometryPersistenceError>;
+}>;
+
+export declare interface GeometryStorage {
+    readonly source: Context.Service.Shape<typeof GeometryStaticSourcePort>;
+    /** Actual native artifact only. Durable operation and exact claim survive unknown replies. */
+    store(tenantId: string, artifact: GeometryArtifact): Effect.Effect<GeometryStaticReference, GeometryPersistenceError>;
+    /** Application version-retirement policy must first fence all manifest/readers.
+     * Only this exact named claim is released; metadata is not physical-absence proof. */
+    release(reference: GeometryStaticReference): Effect.Effect<void, GeometryPersistenceError>;
+}
+
+export declare interface GeometryStorageOptions {
+    /** Actual StorageService bucket and durable metadata boundary. No default store is constructed. */
+    readonly bucket: string;
+    readonly metadata: Pick<StorageObjectMetadata, 'lookup'>;
+    readonly destination?: string;
+    readonly visibility?: 'private' | 'public';
+    readonly maxBytes?: number | undefined;
+    readonly codecLimits?: {
+        readonly [K in GeometryKind]?: GeometryArtifactLimits<K>;
+    } | undefined;
+    /** Trusted server policy. Private reads are not authorized by a digest/ref ID. */
+    readonly authorize: (operation: 'store' | 'load' | 'release', reference: GeometryStaticReference) => Effect.Effect<void, GeometryPersistenceError>;
+}
+
+export declare interface GeometryStorageReadGrantOptions {
+    readonly bucket: string;
+    readonly metadata: Pick<StorageObjectMetadata, 'lookup'>;
+    /** Actual mounted API origin for provider-returned relative serve URLs. */
+    readonly origin: string;
+    readonly visibility?: 'private' | 'public';
+    readonly expiresInSec?: number;
+    readonly maxBytes?: number | undefined;
+    /** Current World/layer/version/chunk rights for actual authenticated Subject. */
+    readonly authorize: (reference: GeometryStaticReference, subject: Subject) => Effect.Effect<void, GeometryPersistenceError>;
+}
+
+export declare interface GeometryStorageReadGrants {
+    grant(reference: GeometryStaticReference, subject: Subject): Effect.Effect<string, GeometryPersistenceError>;
+}
+
+/** Authorized layer-set projection of an immutable version plus independently
+ * observed SQL dirty revisions, not one global actor frame or a read grant. */
+export declare interface GeometryStreamManifest {
+    readonly scope: GeometryPreparedScope;
+    readonly manifestSha256: string;
+    readonly chunks: ReadonlyArray<GeometryStaticReference>;
+    readonly dirtyChunks: ReadonlyArray<GeometryDirtyChunkReference>;
+}
+
+export declare interface GeometrySubjectOperation {
+    readonly receipt: GeometryPersistenceReceipt;
+    readonly patch: Uint8Array;
+}
+
+declare interface GeometryTileCellBounds {
+    readonly minXRaw: number;
+    readonly minYRaw: number;
+    readonly maxXRaw: number;
+    readonly maxYRaw: number;
+}
+
+declare type GeometryTileChunk = (typeof GeometryTileChunkSchema)["Type"];
+
+declare const GeometryTileChunkSchema: Schema.Struct<{
+    readonly kind: Schema.Literal<"2d-tiles">;
+    readonly formatVersion: Schema.Literal<1>;
+    readonly address: Schema.Struct<{
+        readonly worldId: Schema.String;
+        readonly layerSetId: Schema.String;
+        readonly cx: Schema.Int;
+        readonly cy: Schema.Int;
+    }>;
+    readonly version: Schema.String;
+    readonly width: Schema.Int;
+    readonly height: Schema.Int;
+    readonly tileSizeRaw: Schema.Int;
+    readonly palette: Schema.$Array<Schema.Struct<{
+        readonly key: Schema.String;
+        readonly solid: Schema.Boolean;
+    }>>;
+    readonly runs: Schema.$Array<Schema.Struct<{
+        readonly paletteIndex: Schema.Int;
+        readonly length: Schema.Int;
+    }>>;
+}>;
+
+declare interface GeometryTileCollisionOptions {
+    /** Total visited cells across every solver query, including its final check.
+     * May only narrow the world's maxOverlapTests. */
+    readonly maxTests?: number;
+    /** Existing discrete solver limit; defaults to 8, maximum 256. */
+    readonly maxIterations?: number;
+}
+
+declare interface GeometryTileLimits {
+    readonly maxSide: number;
+    readonly maxCells: number;
+    readonly maxPalette: number;
+    readonly maxRuns: number;
+    readonly maxBytes: number;
+}
+
+declare type GeometryTileMaterial = (typeof GeometryTileMaterialSchema)["Type"];
+
+declare const GeometryTileMaterialSchema: Schema.Struct<{
+    readonly key: Schema.String;
+    readonly solid: Schema.Boolean;
+}>;
+
+declare interface GeometryTileView {
+    readonly chunk: GeometryTileChunk;
+    /** Local integer cell queries. Outside cells refuse; no missing-neighbor air. */
+    materialAt(x: number, y: number): GeometryTileMaterial;
+    solidAt(x: number, y: number): boolean;
+    materialAtRaw(xRaw: number, yRaw: number): GeometryTileMaterial;
+    cellBounds(x: number, y: number): GeometryTileCellBounds;
+    /** Detached row-major little-bit occupancy, never the retained mutable grid. */
+    occupancy(): Uint8Array;
+}
+
+declare interface GeometryVersionActivation {
+    readonly _tag: 'GeometryVersionActivation';
+    readonly receipts: ReadonlyArray<GeometryMigrationReceipt>;
+}
+
+export declare interface GeometryVersionActivationOptions {
+    readonly migrations: Context.Service.Shape<typeof GeometryVersionMigrationPort>;
+    readonly persistence: Context.Service.Shape<typeof GeometryPersistencePort>;
+    /** Actual writer quiescence/lease admission; never a successful default. Must
+     * settle the old graph before preparation and retain fencing until activation. */
+    readonly quiesce: (actor: GeometryActorInventory) => Effect.Effect<void, GeometryPersistenceError>;
+    readonly maxChunks?: number | undefined;
+    readonly maxAccountedBytes?: number;
+}
+
+export declare interface GeometryVersionMigrationInput {
+    readonly from: {
+        readonly reference: GeometryStaticReference;
+        readonly static: GeometryArtifact;
+        readonly current: GeometryPersistenceObservation;
+    };
+    readonly to: {
+        readonly reference: GeometryStaticReference;
+        readonly static: GeometryArtifact;
+    };
+}
+
+export declare const geometryVersionMigrationLayer: (service: Context.Service.Shape<typeof GeometryVersionMigrationPort>) => Layer.Layer<GeometryVersionMigrationPort>;
+
+export declare interface GeometryVersionMigrationOptions {
+    readonly strategies?: GeometryVersionPreparationStrategies | undefined;
+    readonly maxAccountedBytes?: number;
+    readonly maxPatchBytes?: number | undefined;
+    readonly codecLimits?: {
+        readonly [K in GeometryKind]?: GeometryArtifactLimits<K>;
+    } | undefined;
+}
+
+export declare class GeometryVersionMigrationPort extends GeometryVersionMigrationPort_base {
+}
+
+declare const GeometryVersionMigrationPort_base: Context.ServiceClass<GeometryVersionMigrationPort, "@voltro/GeometryVersionMigrationPort", {
+    migrate(input: GeometryMigrationRequest): Effect.Effect<GeometryMigrationReceipt, GeometryPersistenceError>;
+    exportSubject(target: GeometryPrivacyTarget): Effect.Effect<ReadonlyArray<GeometryMigrationReceipt>, GeometryPersistenceError>;
+    eraseSubject(target: GeometryPrivacyTarget): Effect.Effect<void, GeometryPersistenceError>;
+}>;
+
+export declare interface GeometryVersionMigrationStrategies {
+    readonly migrateDelta?: GeometryMigrateDelta;
+}
+
+export declare interface GeometryVersionPreparationStrategies extends GeometryVersionMigrationStrategies, Partial<GeometryCompactionStrategies> {
+}
+
+export declare interface GeometryVersionPublication {
+    readonly tenantId: string;
+    readonly kind: GeometryKind;
+    readonly worldId: string;
+    readonly version: string;
+    readonly chunks: ReadonlyArray<GeometryStaticReference>;
+}
+
+export declare interface GeometryVersionReceipt {
+    readonly tenantId: string;
+    readonly kind: GeometryKind;
+    readonly worldId: string;
+    readonly version: string;
+    readonly manifestSha256: string;
+    readonly chunks: ReadonlyArray<GeometryStaticReference>;
+}
+
+/** Immutable manifests authorize the exact static bytes; the static source never selects a new version implicitly. */
+export declare const geometryVersionsTable: TableLike;
+
+declare type GeometryVoxelChunk = (typeof GeometryVoxelChunkSchema)["Type"];
+
+declare const GeometryVoxelChunkSchema: Schema.Struct<{
+    readonly kind: Schema.Literal<"3d-voxel">;
+    readonly formatVersion: Schema.Literal<1>;
+    readonly address: Schema.Struct<{
+        readonly worldId: Schema.String;
+        readonly layerSetId: Schema.String;
+        readonly cx: Schema.Int;
+        readonly cy: Schema.Int;
+        readonly cz: Schema.Int;
+    }>;
+    readonly version: Schema.String;
+    readonly side: Schema.Int;
+    readonly voxelSizeRaw: Schema.Int;
+    readonly palette: Schema.$Array<Schema.Struct<{
+        readonly key: Schema.String;
+        readonly solid: Schema.Boolean;
+    }>>;
+    readonly sections: Schema.$Array<Schema.Struct<{
+        readonly sx: Schema.Int;
+        readonly sy: Schema.Int;
+        readonly sz: Schema.Int;
+        readonly runs: Schema.$Array<Schema.Struct<{
+            readonly paletteIndex: Schema.Int;
+            readonly length: Schema.Int;
+        }>>;
+    }>>;
+}>;
+
+declare interface GeometryVoxelLimits {
+    readonly maxSide: number;
+    readonly maxVoxels: number;
+    readonly maxPalette: number;
+    readonly maxSections: number;
+    readonly maxRunsPerSection: number;
+    readonly maxBytes: number;
+}
+
+declare interface GeometryVoxelView {
+    readonly chunk: GeometryVoxelChunk;
+    materialAt(x: number, y: number, z: number): GeometryTileMaterial;
+    solidAt(x: number, y: number, z: number): boolean;
+    materialAtRaw(xRaw: number, yRaw: number, zRaw: number): GeometryTileMaterial;
+    occupancy(): Uint8Array;
+}
+
+/** Nonempty half-open raw box. Three-dimensional kinds require both Z fields. */
+declare interface GeometryWorldBoxRaw {
+    readonly minXRaw: number;
+    readonly minYRaw: number;
+    readonly maxXRaw: number;
+    readonly maxYRaw: number;
+    readonly minZRaw?: number;
+    readonly maxZRaw?: number;
+}
+
+declare interface GeometryWorldPointRaw {
+    readonly xRaw: number;
+    readonly yRaw: number;
+    readonly zRaw?: number;
+}
+
+declare type GeometryWorldRayHit = GeometryGridRayHit | GeometryShapeRayHit | GeometryHeightfieldRayHit;
+
+declare interface GeometryWorldRayOptions extends GeometryGridRayOptions {
+    /** Shapes only; narrows maxOverlapTests for the total shape scan. */
+    readonly maxTests?: number;
+}
+
+declare interface GeometryWorldShapeHit {
+    readonly scope: GeometryPersistenceScope;
+    readonly revision: number;
+    readonly shape: GeometryShape;
+}
+
+declare interface GeometryWorldView {
+    readonly kind: GeometryKind;
+    readonly scope: GeometryPreparedScope;
+    /** Discrete AABB/circle resolution in world units against current tile data.
+     * Reuses the Transform solver; no swept movement or velocity integration. */
+    collide(transform: Transform2D, body: CollisionBody2D, options?: GeometryTileCollisionOptions): CollisionResult2D;
+    /** Tiles/voxels only. Unloaded coordinates refuse, never implicit empty terrain. */
+    materialAtRaw(point: GeometryWorldPointRaw): GeometryTileMaterial;
+    /** Tiles/voxels/shapes: the stored solidity. Heightfields (points with `zRaw`): terrain is solid at and
+     * below its surface, the same surface `raycastRaw` hits. Heightfield material is not invented. */
+    solidAtRaw(point: GeometryWorldPointRaw): boolean;
+    /** Heightfield only, with exact existing native interpolation. */
+    heightAtRaw(point: GeometryWorldPointRaw): number;
+    /** Shapes only; hit volumes retain native LOCAL coordinates and exact chunk scope. */
+    shapesAtRaw(point: GeometryWorldPointRaw): ReadonlyArray<GeometryWorldShapeHit>;
+    /** Tiles/voxels return exact rational entry; shapes select exact quadratic
+     * entry and expose enclosing presentation bounds; heightfields (points with
+     * `zRaw`) return the first sampled point at or below the surface, refined to
+     * one raw unit (`raycastGeometryHeightfield`). Missing coverage refuses. */
+    raycastRaw(from: GeometryWorldPointRaw, to: GeometryWorldPointRaw, options?: GeometryWorldRayOptions): GeometryWorldRayHit | null;
+    /** Tiles/voxels/closed native shapes, clipped by half-open chunk ownership. Heightfields need the z extent:
+     * the box touches terrain when the highest surface point over its footprint is at or above `minZRaw`
+     * (`overlapsGeometryHeightfieldBox`). Nonempty half-open raw boxes only; missing data or work exhaustion refuses. */
+    overlapsBoxRaw(box: GeometryWorldBoxRaw, options?: GeometryBoxOverlapOptions): boolean;
+    /** Translation-only tile/voxel sweep. Shares maxOverlapTests; validates the
+     * whole swept bounding region before publishing the earliest overlap. */
+    sweepBoxRaw(from: GeometryWorldBoxRaw, to: GeometryWorldBoxRaw, options?: GeometryBoxOverlapOptions): GeometryGridSweepHit | null;
+    /** Heightfields only (boxes with a z extent): the first raw-grid position that reaches under the surface
+     * (`sweepGeometryHeightfieldBox`), coarse steps of a quarter sample spacing, at most
+     * `geometry.budgets.maxRayCells` overlap evaluations of `maxTests` reads each. */
+    sweepHeightfieldBoxRaw(from: GeometryHeightfieldBoxRaw, to: GeometryHeightfieldBoxRaw, options?: GeometryBoxOverlapOptions): GeometryHeightfieldSweepHit | null;
+}
+
+/** Server-only offline author decoder. Literal greyscale 8/16-bit PNG samples,
+ * exact bounded inflate/CRC/filter reconstruction, never a display conversion.
+ * Run outside live Tick; no file/provider/SQL access or border extrapolation. */
+export declare const importPngGeometry: (offered: Uint8Array, options: GeometryPngImportOptions) => ReadonlyArray<GeometryHeightfieldChunk>;
+
+/** Normal offline author source only. SQL stays runtime truth; this file source
+ * cannot select a runtime version or bypass actual Storage/SQL publication. */
+export declare const loadImportedGeometryPublication: (offeredWorld: AnyWorldDescriptor, offeredRequest: GeometryImportedSourceRequest, offeredOptions?: GeometryImportPublicationOptions) => Effect.Effect<GeometryImportPublication, GeometryPersistenceError>;
+
+/** Before actual cell open: derive the complete declared cell+margin inventory,
+ * then await the same real public Tag/SQL/static rebuild and native query guards.
+ * Failure returns no partial inventory. The actual Host must await this Effect
+ * before admission/open; this helper does not invent an open capability. */
+export declare const loadPreparedWorldCellGeometry: (world: AnyWorldDescriptor, root: GeometryPreparedScope, position: WorldPosition, offered?: GeometryPreparedCellLoadOptions) => Effect.Effect<GeometryPreparedCell, GeometryPersistenceError, GeometryPersistencePort>;
+
+/** Actual public persistence Tag -> SQL/static rebuild -> native prepared views.
+ * Entire caller-selected inventory is admitted before provider reads. Workers
+ * stop scheduling after a failure and join started work before reporting it.
+ * No partial result, implicit missing terrain, host activation or timers. */
+export declare const loadPreparedWorldGeometry: (offeredWorld: AnyWorldDescriptor, offeredRoot: GeometryPreparedScope, offeredCoordinates: ReadonlyArray<GeometryPreparedCoordinate>, offered?: GeometryPreparedLoadOptions) => Effect.Effect<GeometryPreparedInventory, GeometryPersistenceError, GeometryPersistencePort>;
+
+/** Reuse the actual compare-only lease owner; no second token/renew/release implementation. */
+export declare const makeGeometryChunkLeases: (hot: HotStoreShape, options: GeometryChunkLeaseOptions) => GeometryChunkLeases;
+
+/** One bounded outside-Tick request/lease lifetime around the actual public SQL
+ * port. Hot leases coordinate preparation only; SQL owner/revision/hash checks
+ * remain authority across expiry and the non-atomic HotStore/SQL boundary. No
+ * timers, automatic renewals/retries, actor activation or client ACK. */
+export declare const makeGeometryCommitCoordinator: (source: Context.Service.Shape<typeof GeometryPersistencePort>, offeredLeases: GeometryChunkLeases, offered: GeometryCommitCoordinatorOptions) => GeometryCommitCoordinator;
+
+/** Own bounded ingress memory; borrow the real edit owner/session/identity
+ * services. Retain accepted intents across unknown outcomes/reconnect. */
+export declare const makeGeometryEditIngress: (offeredOwner: GeometryPlayerEditOwner, offered: GeometryEditIngressOptions) => GeometryEditIngress;
+
+/** Capture the explicit real archive backend once. No fallback or second wire
+ * format: full inline native GPD, or an explicit empty S3 tier marker whose
+ * actual indexed private native GPD source must confirm the same receipt. */
+export declare const makeGeometryJournalPatchReader: (offered?: GeometryJournalPatchReaderOptions) => (row: Row) => Effect.Effect<Uint8Array, GeometryPersistenceError>;
+
+/** Actual SQL/source Port ->authorized current native reliable metadata writes.
+ * Explicit outside-Tick call, no timer/automatic Host hook/blob transfer/ACK. */
+export declare const makeGeometryManifestPublication: (offered: GeometryManifestPublicationOptions) => (() => Effect.Effect<void, GeometryPersistenceError>);
+
+/** Bounded outside-Tick intent lifetime. Borrows the actual CPU/coordinator and
+ * policy/publication capabilities; does not own their shutdown or app terrain
+ * redaction. Only confirmed publication or actual Subject erase forgets work. */
+export declare const makeGeometryPlayerEditOwner: (cpu: GeometryActorInventory, coordinator: GeometryCommitCoordinator, offered: GeometryPlayerEditOwnerOptions) => GeometryPlayerEditOwner;
+
+/** Actual ordinary native Session writer/compiled reliable channel. Snapshot
+ * current recipients, authorize each, await every tracked fragment write. No
+ * datagrams, static CDN blobs, remote ACK, silent skip or private transport. */
+export declare const makeGeometryReliablePublication: (offered: GeometryReliablePublicationOptions) => ((publication: GeometryPlayerEditPublication) => Effect.Effect<void, GeometryCommitCoordinatorError>);
+
+/** Outside-Tick local lifetime: authentic preparation under original physical
+ * chunk lease -> joined release -> existing native commit coordinator/SQL CAS.
+ * Same-request exact bytes survive a lost reply within this owner. No durable
+ * prepared-job recovery, CPU activation or automatic retry is claimed. */
+export declare const makeGeometryRollbackCoordinator: (preparation: Context.Service.Shape<typeof GeometryRollbackPreparationPort>, persistence: Context.Service.Shape<typeof GeometryPersistencePort>, offeredLeases: GeometryChunkLeases, offered: GeometryRollbackCoordinatorOptions) => GeometryRollbackCoordinator;
+
+/** Actual default graph, acquired before actor creation. It owns ingress/edit/
+ * coordinator memory and lease release; persistence/Hot/transport remain borrowed.
+ * Real current Sessions are supplied by Runtime, not by player data or SQL hints. */
+export declare const makeRoomGeometryMutations: (offeredResource: RoomGeometryResource, currentSessions: () => ReadonlyArray<unknown>, offered: RoomGeometryMutationOptions) => RoomGeometryMutationLifetime;
+
+/** Real original chunk lease owner +actual migration/rebuild Ports. Owns bounded
+ * per-resource coordination only; borrowed registry/Hot/SQL lifetimes remain
+ * with the application. SQL remains authority across lease expiry. */
+export declare const makeRoomGeometryReloadSource: (offered: RoomGeometryReloadSourceOptions) => Context.Service.Shape<typeof RoomGeometryReloadPort>;
+
+/** Actual native resource, after default cell loader or a selected real Port.
+ * Owns CPU frame/navigation; release must join app-owned room-specific readers.
+ * Borrowed global SQL/Registry pools are never closed by this helper. */
+export declare const makeRoomGeometryResource: (offeredWorld: AnyWorldDescriptor, offeredScope: RoomGeometryOwnerScope, offeredInventory: GeometryPreparedInventory, release: () => Promise<void>, offeredDirectory?: RoomGeometryDirectoryLifetime, mutationFactory?: RoomGeometryMutationFactory, streamFactory?: RoomGeometryStreamFactory, maxSubjectFences?: number) => RoomGeometryResource;
+
+/** Same real SQL preparation/native coordinator/original physical leases. Weak
+ * Resource-owned bounded jobs retain exact local unknown outcomes; no pool,
+ * automatic backend fallback, process recovery or durable job table. */
+export declare const makeRoomGeometryRollbackSource: (offered: RoomGeometryRollbackSourceOptions) => Context.Service.Shape<typeof RoomGeometryRollbackPort>;
+
+/** Normal optional read-only Host ingress. Callback captures native intentions
+ * only; actual rights/SQL/static/hash/reply run in awaited outside-Tick pump. */
+export declare const makeRoomGeometrySnapshotServer: (offeredResource: RoomGeometryResource, currentSessions: () => ReadonlyArray<unknown>, offered: RoomGeometrySnapshotServerOptions) => RoomGeometrySnapshotServer;
+
+/** Actual optional static/dynamic Host graph. SQL/source metadata happens in the
+ * awaited control pump, never in actor Tick; only new roster/CPU/invalidation
+ * stamp triggers publication. Rights changes must explicitly invalidate. */
+export declare const makeRoomGeometryStreams: (offeredResource: RoomGeometryResource, currentSessions: () => ReadonlyArray<unknown>, offered: RoomGeometryStreamOptions) => RoomGeometryStreamLifetime;
+
+declare class NotRoomMember extends NotRoomMember_base {
+}
+
+declare const NotRoomMember_base: Schema.Class<NotRoomMember, Schema.TaggedStruct<"NotRoomMember", {
+    readonly sessionId: Schema.String;
+}>, YieldableError>;
+
+/** Real separate native thread; package asset and World module come from the
+ * explicit app's ordinary installed dependency. No guessed callback serialization,
+ * implicit source transpilation/eval, fallback generator, Store/Tick or inherited secrets. */
+export declare const openGeometryProceduralWorker: (offeredWorld: AnyWorldDescriptor, offered: GeometryProceduralWorkerOptions) => Effect.Effect<GeometryProceduralWorker, GeometryPersistenceError>;
+
+declare interface PreparedCommon {
+    readonly scope: GeometryPersistenceScope;
+    readonly revision: number;
+    readonly blobSha256: string;
+    readonly contentSha256: string;
+    readonly accountedBytes: number;
+}
+
+/** Outside-Tick genuine before-frame -> actual Delta/digests/native query views
+ * under original inventory budgets -> selected trusted server commit -> sealed
+ * CPU activation. No player RPC, automatic actor callback or reliable delivery. */
+export declare const prepareGeometryActivation: (actor: GeometryActorInventory, source: Pick<GeometryCommitCoordinator, "commit">, offeredInput: GeometryPersistenceCommit, offered?: GeometryActivationOptions) => Effect.Effect<GeometryActivation, GeometryCommitCoordinatorError>;
+
+/** Same actual source/SQL/static Ports; no private table/read pool/current version
+ * inference, full static blob socket transfer or Tick installation. */
+export declare const prepareGeometryChunkSnapshot: (offeredScope: GeometryPersistenceScope, offeredRequest: string, offered: GeometrySnapshotPreparationOptions) => Effect.Effect<GeometryChunkSnapshot, GeometryPersistenceError>;
+
+/** Native canonical hashing and normal manifest capture for offline imports or
+ * author producers. No provider/SQL/Tick acquisition and no fabricated receipt. */
+export declare const prepareGeometryImportPublication: (offeredTenant: string, offeredChunks: ReadonlyArray<GeometryChunk>, offeredOptions?: GeometryImportPublicationOptions) => Promise<GeometryImportPublication>;
+
+/** Outside-Tick native admission + captured server facts + intent-only default
+ * guard/rule slots -> actual native artifact/GPD. No Store/Hot/network work.
+ * Retain this exact server commit across unknown results; do not derive a new
+ * operation from changed terrain when retrying the same request. */
+export declare const prepareGeometryPlayerCommit: (actor: GeometryActorInventory, offered: GeometryPlayerEditRequest, offeredAuthority: GeometryEditAuthority, offeredStrategies?: Partial<GeometryEditStrategies>) => Effect.Effect<GeometryPersistenceCommit, ProtocolError | BudgetExceeded>;
+
+/** Actual confirmed per-chunk migration/replay +normal SQL rebuild, then sealed
+ * whole native inventory. Partial SQL progress retains receipts; CPU unchanged
+ * until explicit activateVersion, never a transaction-wide rollback inference. */
+export declare const prepareGeometryVersionActivation: (actor: GeometryActorInventory, offeredWorld: AnyWorldDescriptor, offered: {
+    readonly owner: GeometryPersistenceOwner;
+    readonly version: string;
+    readonly requestId: string;
+}, options: GeometryVersionActivationOptions) => Effect.Effect<GeometryVersionActivation, GeometryPersistenceError>;
+
+export declare const prepareGeometryVersionMigration: (offeredWorld: AnyWorldDescriptor, offeredInput: GeometryVersionMigrationInput, offeredOptions?: GeometryVersionMigrationOptions) => Effect.Effect<GeometryPreparedVersionMigration, GeometryPersistenceError>;
+
+/** Whole explicit authored inventory, outside Tick. Actual owned Workers stop
+ * scheduling on failure, join accepted jobs and all native exits. SQL/Storage
+ * publication stays explicit; this cannot grow an existing immutable manifest. */
+export declare const prepareProceduralGeometryPublication: (offeredWorld: AnyWorldDescriptor, offeredRoot: GeometryPreparedScope, offeredCoordinates: ReadonlyArray<GeometryPreparedCoordinate>, offeredWorker: GeometryProceduralWorkerOptions, offeredOptions?: GeometryProceduralPublicationOptions) => Effect.Effect<GeometryImportPublication, GeometryPersistenceError>;
+
+declare class ProtocolError extends ProtocolError_base {
+    get message(): string;
+}
+
+declare const ProtocolError_base: Schema.Class<ProtocolError, Schema.TaggedStruct<"ProtocolError", {
+    readonly detail: Schema.String;
+}>, YieldableError>;
+
+/** Whole owned genuine author inventory -> actual deterministic Storage writes
+ * -> exact atomic SQL manifest. Stop scheduling after a failure and join all
+ * started writes. No partial manifest/empty chunk, automatic retry or unsafe
+ * orphan deletion. Repeat the same artifacts after unknown outcomes; actual
+ * claim/version-retirement lifecycle must resolve unreferenced stored objects. */
+export declare const publishGeometryArtifacts: (offeredWorld: AnyWorldDescriptor, offeredStorage: GeometryStorage, offeredSource: Pick<Context.Service.Shape<typeof GeometryPersistencePort>, "publish">, offeredInput: GeometryArtifactPublication, offered?: GeometryArtifactPublicationOptions) => Effect.Effect<GeometryVersionReceipt, GeometryPersistenceError>;
+
+/** `select` for World cell Rooms: the recorded cell (the World allocation records it before the Room installs)
+ * with your layer set and version. A Room without a recorded cell is not a World cell Room and fails. */
+export declare const recordedGeometryPlacement: (worlds: ReadonlyArray<AnyWorldDescriptor>, recorded: WorldCellIdentity | null, choice: {
+    readonly layerSetId: string;
+    readonly version: string;
+    readonly load?: GeometryPreparedCellLoadOptions;
+}) => Effect.Effect<RoomGeometryPlacement, GeometryPersistenceError>;
+
+declare class RoomAuthoringError extends RoomAuthoringError_base {
+    get message(): string;
+}
+
+declare const RoomAuthoringError_base: Schema.Class<RoomAuthoringError, Schema.TaggedStruct<"RoomAuthoringError", {
+    readonly room: Schema.String;
+    readonly detail: Schema.String;
+}>, YieldableError>;
+
+declare type RoomControlError = ProtocolError | BudgetExceeded | NotRoomMember | RoomAuthoringError | RoomForbidden | RoomFull | RoomGone | RoomLocked | RoomPoolWaking | RoomsClosed | SeatExpired;
+
+declare class RoomForbidden extends RoomForbidden_base {
+}
+
+declare const RoomForbidden_base: Schema.Class<RoomForbidden, Schema.TaggedStruct<"RoomForbidden", {
+    readonly roomId: Schema.String;
+}>, YieldableError>;
+
+declare class RoomFull extends RoomFull_base {
+}
+
+declare const RoomFull_base: Schema.Class<RoomFull, Schema.TaggedStruct<"RoomFull", {
+    readonly roomId: Schema.String;
+}>, YieldableError>;
+
+export declare const roomGeometryAdministrationLayer: (source: Context.Service.Shape<typeof RoomGeometryAdministrationPort>) => Layer.Layer<RoomGeometryAdministrationPort>;
+
+/** API administration resolves actual current SQL Host; wire inputs never select it. */
+export declare class RoomGeometryAdministrationPort extends RoomGeometryAdministrationPort_base {
+}
+
+declare const RoomGeometryAdministrationPort_base: Context.ServiceClass<RoomGeometryAdministrationPort, "@voltro/RoomGeometryAdministrationPort", {
+    reload(roomId: string, request: RoomGeometryReloadRequest, subject: Subject): Effect.Effect<void, GeometryPersistenceError>;
+    rollback(roomId: string, request: RoomGeometryRollbackRequest, subject: Subject): Effect.Effect<void, GeometryPersistenceError>;
+    /** The chunk view: present when the administration knows the Worlds. */
+    readonly chunks?: (roomId: string, subject: Subject) => Effect.Effect<RoomGeometryChunks, GeometryPersistenceError>;
+}>;
+
+/** The changed chunks a World cell Room owns, newest first. `truncated` when more exist than the read returns. */
+export declare interface RoomGeometryChunks {
+    readonly roomId: string;
+    readonly worldId: string;
+    readonly zoneId: string;
+    readonly cellId: string;
+    readonly chunks: ReadonlyArray<RoomGeometryChunkState>;
+    readonly truncated: boolean;
+}
+
+/** One chunk a World cell Room owns that players changed: its durable revision and whether it
+ * still differs from its static version (`changed: false` after a reset). */
+export declare interface RoomGeometryChunkState {
+    readonly cx: number;
+    readonly cy: number;
+    readonly cz?: number | undefined;
+    readonly layerSetId: string;
+    readonly version: string;
+    readonly revision: number;
+    readonly changed: boolean;
+    readonly updatedAt: number;
+}
+
+/** Existing authenticated API-to-Host carrier. Caller authority must be
+ * resolved again at the actual Host; success joins native CPU admission and
+ * retained cleanup, never merely receipt publication. No player state input. */
+export declare class RoomGeometryControlPort extends RoomGeometryControlPort_base {
+}
+
+declare const RoomGeometryControlPort_base: Context.ServiceClass<RoomGeometryControlPort, "@voltro/RoomGeometryControlPort", {
+    reload(hostId: string, roomId: string, request: RoomGeometryReloadRequest, subject: Subject): Effect.Effect<void, RoomControlError>;
+    rollback(hostId: string, roomId: string, request: RoomGeometryRollbackRequest, subject: Subject): Effect.Effect<void, RoomControlError>;
+}>;
+
+export declare interface RoomGeometryDirectoryBindingOptions {
+    readonly reload?: Context.Service.Shape<typeof RoomGeometryReloadPort>;
+    readonly rollback?: Context.Service.Shape<typeof RoomGeometryRollbackPort>;
+    readonly worlds: ReadonlyArray<AnyWorldDescriptor>;
+    readonly epochNow: () => number;
+    readonly maxListedCells: number;
+    readonly authorize: WorldCellDirectoryOptions['authorize'];
+    readonly persistence: Context.Service.Shape<typeof GeometryPersistencePort>;
+    /** Current source/placement rights and version selection remain actual app
+     * capabilities. A recorded placement fixes the cell/layer on recovery. */
+    /** Actual synchronously acquired graph; all I/O dependencies are already borrowed. */
+    readonly streams?: RoomGeometryStreamFactory;
+    readonly maxSubjectFences?: number;
+    readonly mutations?: RoomGeometryMutationFactory;
+    readonly select: (scope: RoomGeometryOwnerScope, recorded: WorldCellIdentity | null) => Effect.Effect<RoomGeometryPlacement, GeometryPersistenceError>;
+}
+
+export declare interface RoomGeometryDirectoryLifetime {
+    readonly synchronize: () => Promise<void>;
+}
+
+export declare type RoomGeometryMutationFactory = (resource: RoomGeometryResource, currentSessions: () => ReadonlyArray<unknown>) => RoomGeometryMutationLifetime;
+
+export declare interface RoomGeometryMutationLifetime {
+    readonly channel: string;
+    readonly publicationChannel: string;
+    stage(actualSession: unknown, message: unknown): void;
+    discardUnsubmitted(target: GeometryPrivacyTarget): Promise<boolean>;
+    withdrawSubject(target: GeometryPrivacyTarget): Promise<void>;
+    eraseSubject(target: GeometryPrivacyTarget): Promise<void>;
+    fence(): void;
+    pump(): Promise<void>;
+    close(): Promise<void>;
+}
+
+export declare interface RoomGeometryMutationOptions {
+    readonly persistence: Context.Service.Shape<typeof GeometryPersistencePort>;
+    readonly leases: GeometryChunkLeases;
+    readonly now: () => number;
+    readonly resolveSubject: GeometryEditIngressOptions['resolveSubject'];
+    readonly authorizeIntent: GeometryPlayerEditOwnerOptions['authorizeIntent'];
+    readonly authorizeRecipient: GeometryReliablePublicationOptions['authorizeRecipient'];
+    readonly channel?: string | undefined;
+    readonly coordinator?: Omit<GeometryCommitCoordinatorOptions, 'tenantId'>;
+    readonly edits?: Omit<GeometryPlayerEditOwnerOptions, 'tenantId' | 'now' | 'authorizeIntent' | 'publishCommitted'>;
+    readonly ingress?: Pick<GeometryEditIngressOptions, 'maxPending' | 'maxPerPump' | 'maxSubjectFences'>;
+    readonly publication?: Pick<GeometryReliablePublicationOptions, 'channel' | 'maxRecipients' | 'maxPatchBytes' | 'maxFragmentDeliveries'> | undefined;
+}
+
+export declare interface RoomGeometryOwnerScope {
+    readonly roomId: string;
+    readonly tenantId: string;
+    readonly hostId: string;
+    readonly epoch: number;
+    readonly name: string;
+}
+
+/** Server selection only. This is never read from player options/metadata. */
+export declare interface RoomGeometryPlacement {
+    readonly worldId: string;
+    readonly zoneId: string;
+    readonly at: WorldPoint;
+    readonly layer: number;
+    readonly layerSetId: string;
+    readonly version: string;
+    readonly load?: GeometryPreparedCellLoadOptions;
+}
+
+export declare const roomGeometryReloadLayer: (service: Context.Service.Shape<typeof RoomGeometryReloadPort>) => Layer.Layer<RoomGeometryReloadPort>;
+
+/** Trusted administrative source. The real provider owns migration Ports,
+ * chunk leases/renewals/unknown outcomes and idempotent cleanup for each exact
+ * Room owner/request. No permissive authorization or lease substitute exists. */
+export declare class RoomGeometryReloadPort extends RoomGeometryReloadPort_base {
+}
+
+declare const RoomGeometryReloadPort_base: Context.ServiceClass<RoomGeometryReloadPort, "@voltro/RoomGeometryReloadPort", {
+    authorize(subject: Subject, resource: RoomGeometryResource, request: RoomGeometryReloadRequest): Effect.Effect<void, GeometryPersistenceError>;
+    prepare(resource: RoomGeometryResource, request: RoomGeometryReloadRequest): Effect.Effect<GeometryVersionActivation, GeometryPersistenceError>;
+    /** Reacquire/renew actual coordination and verify the retained preparation
+     * against current SQL before a token retry. No automatic stale-token success. */
+    resume(resource: RoomGeometryResource, request: RoomGeometryReloadRequest, token: GeometryVersionActivation): Effect.Effect<void, GeometryPersistenceError>;
+    /** Compare-only coordination cleanup; never discard durable migration receipts.
+     * Must work after actor/Room withdrawal with the captured owner/request scope. */
+    release(resource: RoomGeometryResource, request: RoomGeometryReloadRequest): Effect.Effect<void, GeometryPersistenceError>;
+}>;
+
+export declare interface RoomGeometryReloadRequest {
+    readonly version: string;
+    readonly requestId: string;
+}
+
+/** Administrative intentions only; Host resolves World/current owner/native bytes. */
+export declare const RoomGeometryReloadRequestSchema: Schema.Struct<{
+    readonly version: Schema.String;
+    readonly requestId: Schema.String;
+}>;
+
+export declare interface RoomGeometryReloadSourceOptions {
+    readonly authorize: (subject: Subject, resource: RoomGeometryResource, request: RoomGeometryReloadRequest) => Effect.Effect<void, GeometryPersistenceError>;
+    readonly migrations: Context.Service.Shape<typeof GeometryVersionMigrationPort>;
+    readonly persistence: Context.Service.Shape<typeof GeometryPersistencePort>;
+    /** Actual app-owned tenant HotStore-backed leases, never a read fallback. */
+    readonly leases: (resource: RoomGeometryResource) => Effect.Effect<GeometryChunkLeases, GeometryPersistenceError>;
+    readonly maxChunks?: number | undefined;
+    readonly maxAccountedBytes?: number;
+}
+
+export declare interface RoomGeometryResource {
+    readonly scope: RoomGeometryOwnerScope;
+    readonly world: AnyWorldDescriptor;
+    readonly inventory: GeometryActorInventory;
+    readonly view: GeometryWorldView;
+    /** Trusted local unsubmitted discard; never a global rejection/SQL receipt. */
+    /** Trusted visibility/source invalidation, queued for the actual Host pump. */
+    invalidateStreams(): void;
+    discardUnsubmitted(target: GeometryPrivacyTarget): Promise<boolean>;
+    /** Writer lifetime only; actual SQL/reader/content erasure stays on the selected source. */
+    withdrawSubject(target: GeometryPrivacyTarget): Promise<void>;
+    eraseSubject(target: GeometryPrivacyTarget): Promise<void>;
+    /** Outside-Tick SQL publication/refresh after the actual Room boundary. */
+    synchronize(): Promise<void>;
+    /** Fence and join both channel graphs without closing the native CPU frame.
+     * Retired graphs stay retired; this alone never installs a new version. */
+    quiesce(): Promise<void>;
+    close(): Promise<void>;
+}
+
+export declare const roomGeometryRollbackLayer: (source: Context.Service.Shape<typeof RoomGeometryRollbackPort>) => Layer.Layer<RoomGeometryRollbackPort>;
+
+export declare class RoomGeometryRollbackPort extends RoomGeometryRollbackPort_base {
+}
+
+declare const RoomGeometryRollbackPort_base: Context.ServiceClass<RoomGeometryRollbackPort, "@voltro/RoomGeometryRollbackPort", {
+    authorize(subject: Subject, resource: RoomGeometryResource, request: RoomGeometryRollbackRequest): Effect.Effect<void, GeometryPersistenceError>;
+    prepare(subject: Subject, resource: RoomGeometryResource, request: RoomGeometryRollbackRequest): Effect.Effect<GeometryActivation, GeometryPersistenceError>;
+    resume(subject: Subject, resource: RoomGeometryResource, request: RoomGeometryRollbackRequest, token: GeometryActivation): Effect.Effect<void, GeometryPersistenceError>;
+    /** Real owned coordination cleanup after failure or success, including after
+     * Resource close. Unknown durable outcomes must remain retained. */
+    release(resource: RoomGeometryResource, request: RoomGeometryRollbackRequest): Effect.Effect<void, GeometryPersistenceError>;
+}>;
+
+/** Administrative intention only. World/version/owner/authority/baseline/patch
+ * are resolved by the actual Host/source, never accepted as client state. */
+export declare interface RoomGeometryRollbackRequest {
+    readonly cx: number;
+    readonly cy: number;
+    readonly cz?: number | undefined;
+    /** The actor whose changes are undone; `null` undoes every actor's changes (chunk reset to its static baseline). */
+    readonly target: GeometryPersistenceSubject | null;
+    readonly requestId: string;
+}
+
+export declare const RoomGeometryRollbackRequestSchema: Schema.Struct<{
+    readonly cx: Schema.Int;
+    readonly cy: Schema.Int;
+    readonly cz: Schema.optional<Schema.Int>;
+    readonly target: Schema.NullOr<Schema.Struct<{
+        readonly id: Schema.String;
+        readonly kind: Schema.Literals<readonly ["user", "guest"]>;
+    }>>;
+    readonly requestId: Schema.String;
+}>;
+
+export declare interface RoomGeometryRollbackSourceOptions {
+    readonly authorize: (subject: Subject, resource: RoomGeometryResource, request: RoomGeometryRollbackRequest) => Effect.Effect<void, GeometryPersistenceError>;
+    readonly preparation: Context.Service.Shape<typeof GeometryRollbackPreparationPort>;
+    readonly persistence: Context.Service.Shape<typeof GeometryPersistencePort>;
+    readonly leases: (resource: RoomGeometryResource) => Effect.Effect<GeometryChunkLeases, GeometryPersistenceError>;
+    readonly maxJobsPerResource?: number;
+    readonly maxPatchBytes?: number | undefined;
+    readonly maxPendingBytes?: number | undefined;
+}
+
+export declare interface RoomGeometrySnapshotServer {
+    readonly requestChannel: string;
+    readonly responseChannel: string;
+    stage(actualSession: unknown, message: unknown): void;
+    withdrawSubject(target: GeometryPrivacyTarget): Promise<void>;
+    fence(): void;
+    pump(): Promise<void>;
+    close(): Promise<void>;
+}
+
+export declare interface RoomGeometrySnapshotServerOptions extends Omit<GeometrySnapshotPreparationOptions, 'authorize'> {
+    readonly resolveSubject: (recipient: GeometryPublicationRecipient) => Effect.Effect<GeometryPersistenceSubject, GeometryPersistenceError>;
+    readonly authorize: (recipient: GeometryPublicationRecipient, scope: GeometryPersistenceScope) => Effect.Effect<void, GeometryPersistenceError>;
+    readonly requestChannel?: string;
+    readonly responseChannel?: string;
+    readonly maxPending?: number | undefined;
+    readonly maxPerPump?: number;
+    readonly maxFragmentDeliveries?: number;
+    readonly maxSubjectFences?: number;
+    readonly maxPendingSnapshotBytes?: number;
+}
+
+export declare type RoomGeometryStreamFactory = (resource: RoomGeometryResource, currentSessions: () => ReadonlyArray<unknown>) => RoomGeometryStreamLifetime;
+
+export declare interface RoomGeometryStreamLifetime {
+    readonly channel: string;
+    readonly recovery?: RoomGeometrySnapshotServer;
+    invalidate(): void;
+    withdrawSubject(target: GeometryPrivacyTarget): Promise<void>;
+    fence(): void;
+    pump(): Promise<void>;
+    close(): Promise<void>;
+}
+
+export declare interface RoomGeometryStreamOptions extends Omit<GeometryManifestPublicationOptions, 'scope' | 'owner' | 'currentSessions'> {
+    /** Actual current server Subject.kind lookup; native seat IDs do not infer it. */
+    readonly resolveSubject: (recipient: GeometryPublicationRecipient) => Effect.Effect<GeometryPersistenceSubject, GeometryPersistenceError>;
+    readonly maxSubjectFences?: number;
+    readonly recovery?: RoomGeometrySnapshotServerOptions;
+}
+
+declare class RoomGone extends RoomGone_base {
+}
+
+declare const RoomGone_base: Schema.Class<RoomGone, Schema.TaggedStruct<"RoomGone", {
+    readonly roomId: Schema.String;
+}>, YieldableError>;
+
+export declare interface RoomHostGeometryBinding {
+    readonly reload?: Context.Service.Shape<typeof RoomGeometryReloadPort>;
+    readonly rollback?: Context.Service.Shape<typeof RoomGeometryRollbackPort>;
+    readonly worlds: ReadonlyArray<AnyWorldDescriptor>;
+    /** Trusted placement/source authorization + complete cell/margin loading,
+     * before actor creation. No player metadata is a World ownership proof. */
+    readonly prepare: (scope: RoomGeometryOwnerScope) => Effect.Effect<RoomGeometryResource, GeometryPersistenceError>;
+    /** After exact creating-Room compensation, retire any actual SQL placement. */
+    readonly cleanupCreation?: (scope: RoomGeometryOwnerScope) => Effect.Effect<void, GeometryPersistenceError>;
+}
+
+declare class RoomLocked extends RoomLocked_base {
+}
+
+declare const RoomLocked_base: Schema.Class<RoomLocked, Schema.TaggedStruct<"RoomLocked", {
+    readonly roomId: Schema.String;
+}>, YieldableError>;
+
+/** The pool has no host because it scaled to zero; one is starting. Reserve again after `retryAfterMs`. */
+declare class RoomPoolWaking extends RoomPoolWaking_base {
+}
+
+declare const RoomPoolWaking_base: Schema.Class<RoomPoolWaking, Schema.TaggedStruct<"RoomPoolWaking", {
+    readonly pool: Schema.String;
+    readonly retryAfterMs: Schema.Number;
+}>, YieldableError>;
+
+/** New Room reservations are closed for this caller (maintenance, a kill switch...): the app's
+ * `admission` refused. `until`: epoch ms when they reopen, if known; `messageKey`: the app's text. */
+declare class RoomsClosed extends RoomsClosed_base {
+}
+
+declare const RoomsClosed_base: Schema.Class<RoomsClosed, Schema.TaggedStruct<"RoomsClosed", {
+    readonly until: Schema.NullOr<Schema.Number>;
+    readonly messageKey: Schema.String;
+}>, YieldableError>;
+
+export declare interface RoomsGeometryHttpOptions {
+    /** Explicit distinct path for this installed plugin instance. */
+    readonly path: string;
+    /** Existing app authentication; raw plugin HTTP routes have no RPC Subject. */
+    readonly resolveSubject: (request: PluginHttpRouteRequest) => Promise<Subject>;
+    /** Current World/layer/version/chunk visibility, not an ID-based grant. */
+    readonly authorizeRead: (scope: GeometryPersistenceScope, subject: Subject) => Effect.Effect<void, ProtocolError>;
+    readonly maxResponseBytes?: number;
+}
+
+/** Normal raw HTTP contribution. Authentication, permanent SQL Subject fence
+ * and current explicit read policy precede the owner's actual source Port.
+ * No anonymous, digest-only grant, private SQL source or fabricated CORS. */
+export declare const roomsGeometryHttpRoute: (worlds: ReadonlyArray<AnyWorldDescriptor>, service: Context.Service.Shape<typeof GeometryPersistencePort>, offered: RoomsGeometryHttpOptions) => PluginHttpRoute;
+
+declare class SeatExpired extends SeatExpired_base {
+}
+
+declare const SeatExpired_base: Schema.Class<SeatExpired, Schema.TaggedStruct<"SeatExpired", {
+    readonly sessionId: Schema.String;
+}>, YieldableError>;
+
+/** Borrow normal StorageService/SQL operation metadata, including its existing
+ * Registry/provider/claim/stream lifetime. No private pool, memory fallback,
+ * second object journal, CDN token, source-version switch or Tick installation. */
+export declare const storageGeometry: (offeredStorage: Pick<StorageServiceShape, "put" | "head" | "getStream" | "delete">, offered: GeometryStorageOptions) => GeometryStorage;
+
+/** Actual published catalogue ->Storage head/current access mint ->catalogue+
+ * head/current rights recheck. No guessed file/URL, grant cache, fallback,
+ * private Storage/SQL connection, new table or graphics/asset decoder. */
+export declare const storageGeometryAssetReadGrants: (offeredStorage: Pick<StorageServiceShape, "head" | "mintUrl">, offered: GeometryAssetStorageGrantOptions) => GeometryAssetStorageGrants;
+
+/** Actual normal StorageService/SQL named operation+claim, storing the original
+ * canonical GPD bytes privately. This never deletes SQL receipts or compacts a
+ * journal; future SQL archive selection must retain its durable index. */
+export declare const storageGeometryJournal: (storage: Pick<StorageServiceShape, "put" | "head" | "getStream" | "delete">, offered: GeometryJournalStorageOptions) => Context.Service.Shape<typeof GeometryJournalArchivePort>;
+
+/** Existing durable operation+held claim ->actual Storage head/access mint URL.
+ * Borrowed Registry/provider/SQL/token issuer; no guessed ref, URL or credential. */
+export declare const storageGeometryReadGrants: (offeredStorage: Pick<StorageServiceShape, "head" | "mintUrl">, offered: GeometryStorageReadGrantOptions) => GeometryStorageReadGrants;
+
+declare const Transform2D: Schema.Struct<{
+    readonly x: Schema.Number;
+    readonly y: Schema.Number;
+    readonly rot: Schema.Number;
+    readonly vx: Schema.optional<Schema.Number>;
+    readonly vy: Schema.optional<Schema.Number>;
+}>;
+
+declare type Transform2D = (typeof Transform2D)["Type"];
+
+declare type WorldBounds = readonly [minimum: WorldPoint, maximum: WorldPoint];
+
+declare interface WorldCell {
+    readonly id: string;
+    readonly zone: string;
+    readonly column: number;
+    readonly row: number;
+    readonly bounds: WorldBounds;
+}
+
+declare interface WorldCellDirectoryOptions {
+    readonly worlds: ReadonlyArray<AnyWorldDescriptor>;
+    readonly epochNow: () => number;
+    readonly maxListedCells: number;
+    /** Real server scope authorization. No implicit client/host assertion is trusted. */
+    readonly authorize: (operation: 'publish' | 'observe' | 'list' | 'remove', scope: WorldCellScope) => Effect.Effect<void, ProtocolError>;
+}
+
+declare interface WorldCellIdentity extends WorldCellScope {
+    readonly zoneId: string;
+    readonly cellId: string;
+    readonly layer: number;
+}
+
+declare interface WorldCellScope {
+    readonly tenantId: string;
+    readonly worldId: string;
+}
+
+declare interface WorldDefinition<Player> {
+    readonly name: string;
+    readonly map: {
+        readonly bounds: WorldBounds;
+    };
+    readonly zones: ReadonlyArray<WorldZone>;
+    readonly instances?: ReadonlyArray<WorldInstance>;
+    readonly persistence: {
+        readonly entities: 'world';
+        readonly snapshotEveryMs: number;
+        readonly journal: boolean;
+    };
+    readonly handoff: {
+        readonly marginUnits: number;
+        readonly ghostUnits: number;
+    };
+    readonly spawn: (context: {
+        readonly player: Player;
+    }) => WorldPosition;
+    readonly geometry?: WorldGeometryDefinition | undefined;
+    readonly hosts?: {
+        readonly pool: string;
+    };
+    readonly characters?: 'shared' | 'per-world';
+    readonly transitionCooldownMs?: number;
+    /** Authoring inventory bounds, not measured runtime capacity. */
+    readonly budgets?: {
+        readonly maxZones?: number;
+        readonly maxCells?: number | undefined;
+        readonly maxInstances?: number;
+    };
+    readonly strategies?: {
+        readonly layerPolicy?: WorldLayerPolicy | undefined;
+        readonly transitionPolicy?: WorldTransitionPolicy;
+        readonly onWorldChange?: WorldOnWorldChange;
+    };
+}
+
+declare interface WorldDescriptor<Player> extends Omit<WorldDefinition<Player>, 'instances' | 'budgets' | 'characters' | 'transitionCooldownMs' | 'strategies' | 'geometry'> {
+    readonly geometry?: WorldGeometryDescriptor | undefined;
+    readonly _tag: 'WorldDescriptor';
+    readonly instances: ReadonlyArray<Omit<WorldInstance, 'ttl'> & {
+        readonly ttlMs: number;
+    }>;
+    readonly budgets: {
+        readonly maxZones: number;
+        readonly maxCells: number;
+        readonly maxInstances: number;
+    };
+    readonly characters: 'shared' | 'per-world';
+    readonly transitionCooldownMs: number;
+    readonly cellCount: number;
+    readonly strategies: {
+        readonly layerPolicy: WorldLayerPolicy;
+        readonly transitionPolicy: WorldTransitionPolicy;
+        readonly onWorldChange: WorldOnWorldChange;
+    };
+}
+
+/** The Subject of a player in a World cell Room, read from its World entity in that Room: the World binding
+ * records the actual user or guest kind when the seat is admitted. No entity of that player in that Room fails. */
+export declare const worldEntityGeometrySubject: (store: DataStore) => (recipient: {
+    readonly tenantId: string;
+    readonly roomId: string;
+    readonly subjectId: string;
+}) => Effect.Effect<GeometryPersistenceSubject, ProtocolError>;
+
+declare interface WorldGeometryDefinition {
+    readonly strategies?: WorldGeometryStrategies | undefined;
+    readonly kind: GeometryKind;
+    readonly static: GeometrySource;
+    readonly chunkSize?: number;
+    readonly dynamic?: {
+        readonly enabled?: boolean | undefined;
+        readonly maxDeltaBytesPerChunk?: number;
+        readonly persist?: {
+            readonly everyMs?: number;
+            readonly onUnload?: boolean;
+        };
+    };
+    readonly collision?: {
+        readonly derive?: 'bitgrid' | 'heightfield' | 'shapes';
+        readonly resolution?: number;
+    };
+    readonly nav?: {
+        readonly derive?: 'grid' | 'none';
+        readonly navBudgetMs?: number;
+        readonly maxAdvanceSteps?: number;
+    };
+    readonly streaming?: {
+        readonly client?: {
+            readonly radiusChunks?: number;
+            readonly prefetchChunks?: number;
+            readonly maxConcurrent?: number | undefined;
+            readonly maxCachedChunks?: number;
+        };
+        readonly cell?: {
+            readonly marginChunks?: number;
+        };
+    };
+    readonly lod?: ReadonlyArray<{
+        readonly beyondChunks: number;
+        readonly fields: ReadonlyArray<string>;
+    }>;
+    readonly budgets?: {
+        readonly maxPreparedChunks?: number;
+        readonly maxPreparedBytes?: number;
+        readonly maxLodLevels?: number;
+        readonly maxRayCells?: number | undefined;
+        readonly maxOverlapTests?: number | undefined;
+    };
+}
+
+declare interface WorldGeometryDescriptor {
+    readonly strategies: GeometryEditStrategies & GeometryDerivationStrategies & GeometryCompactionStrategies & {
+        readonly migrateDelta: GeometryMigrateDelta;
+    };
+    readonly _tag: 'WorldGeometry';
+    readonly kind: GeometryKind;
+    readonly static: GeometrySource;
+    readonly chunkSize: number;
+    readonly chunkSizeRaw: number;
+    readonly dynamic: {
+        readonly enabled: boolean;
+        readonly maxDeltaBytesPerChunk: number;
+        readonly persist: {
+            readonly everyMs: number;
+            readonly onUnload: boolean;
+        };
+    };
+    readonly collision: {
+        readonly derive: 'bitgrid' | 'heightfield' | 'shapes';
+        readonly resolution: number;
+        readonly resolutionRaw: number;
+    };
+    readonly nav: {
+        readonly derive: 'grid' | 'none';
+        readonly navBudgetMs: number;
+        readonly maxAdvanceSteps: number;
+    };
+    readonly streaming: {
+        readonly client: {
+            readonly radiusChunks: number;
+            readonly prefetchChunks: number;
+            readonly maxConcurrent: number;
+            readonly maxCachedChunks: number;
+        };
+        readonly cell: {
+            readonly marginChunks: number;
+        };
+    };
+    readonly lod: ReadonlyArray<{
+        readonly beyondChunks: number;
+        readonly fields: ReadonlyArray<string>;
+    }>;
+    readonly budgets: {
+        readonly maxPreparedChunks: number;
+        readonly maxPreparedBytes: number;
+        readonly maxLodLevels: number;
+        readonly maxRayCells: number;
+        readonly maxOverlapTests: number;
+    };
+}
+
+declare interface WorldGeometryStrategies extends GeometryVersionMigrationStrategies, Partial<GeometryEditStrategies>, Partial<GeometryDerivationStrategies>, Partial<GeometryCompactionStrategies> {
+}
+
+declare interface WorldInstance {
+    readonly id: string;
+    readonly room: string;
+    readonly maxGroups: number;
+    readonly ttl: Duration.Input;
+}
+
+declare type WorldLayerDecision = {
+    readonly kind: 'use';
+    readonly layer: number;
+    readonly wake: boolean;
+} | {
+    readonly kind: 'create';
+    readonly layer: number;
+} | {
+    readonly kind: 'blocked';
+    readonly reason: 'affinity-unavailable' | 'capacity' | 'layer-budget';
+};
+
+declare interface WorldLayering {
+    readonly maxPlayers: number;
+    readonly splitAt: number;
+    readonly mergeBelow: number;
+}
+
+declare interface WorldLayerInput {
+    readonly policy: WorldLayering;
+    readonly layers: ReadonlyArray<WorldLayerObservation>;
+    readonly groupSize: number;
+    /** Actual server-owned party affinity; never silently choose a different layer. */
+    readonly affinity: number | null;
+    readonly maxLayers: number;
+}
+
+declare interface WorldLayerObservation {
+    readonly layer: number;
+    readonly players: number;
+    readonly state: 'live' | 'hibernated' | 'splitting' | 'merging';
+}
+
+declare type WorldLayerPolicy = (input: WorldLayerInput) => WorldLayerDecision;
+
+declare type WorldOnWorldChange = (input: WorldOnWorldChangeInput) => unknown;
+
+declare interface WorldOnWorldChangeInput {
+    readonly sourceWorldId: string;
+    readonly targetWorldId: string;
+    /** Current server-captured character data, never a player's wire state. */
+    readonly sourceData: unknown;
+    /** Actual server-selected target data before this policy. */
+    readonly targetData: unknown;
+}
+
+declare type WorldPoint = readonly [x: number, y: number];
+
+declare interface WorldPosition {
+    readonly zone: string;
+    readonly at: WorldPoint;
+}
+
+declare type WorldTransitionKind = 'cell' | 'layer' | 'zone' | 'world' | 'instance' | 'return' | 'recover';
+
+/** Opaque temporary ownership. SQL must still fence durable entity commits. */
+declare interface WorldTransitionLease {
+    /** False means absent/expired/replaced; never continue a transition on false. */
+    renew(): Effect.Effect<boolean, HotError | ProtocolError>;
+    /** Compare-only release cannot remove a successor. Repeated release returns false. */
+    release(): Effect.Effect<boolean, HotError | ProtocolError>;
+}
+
+declare interface WorldTransitionLeaseOptions {
+    readonly namespace: string;
+    readonly tenantId: string;
+    readonly ttlMs: number;
+}
+
+declare interface WorldTransitionLocation extends WorldPosition {
+    readonly world: string;
+    readonly pool: string;
+    readonly layer: number;
+    readonly instance: string | null;
+}
+
+declare type WorldTransitionMode = 'seamless' | 'portal' | 'recover';
+
+declare interface WorldTransitionPlan {
+    readonly kind: WorldTransitionKind;
+    readonly mode: WorldTransitionMode;
+    readonly crossPool: boolean;
+    readonly persistBeforeRelease: boolean;
+    readonly sourceCell: string;
+    readonly targetCell: string;
+}
+
+declare type WorldTransitionPolicy = (input: WorldTransitionPolicyInput) => WorldTransitionPlan;
+
+declare interface WorldTransitionPolicyInput {
+    readonly kind: WorldTransitionKind;
+    readonly sourceWorld: AnyWorldDescriptor;
+    readonly targetWorld: AnyWorldDescriptor;
+    readonly source: WorldTransitionLocation;
+    readonly target: WorldTransitionLocation;
+    readonly mode: WorldTransitionMode | 'auto';
+    readonly crossPool: boolean;
+    /** Trusted server recovery classification, not a player intention field. */
+    readonly recovery: boolean;
+}
+
+declare interface WorldZone {
+    readonly id: string;
+    readonly bounds: WorldBounds;
+    readonly room: string;
+    readonly neighbors: ReadonlyArray<string>;
+    readonly cells?: {
+        readonly size: number;
+    } | undefined;
+    readonly layering?: WorldLayering;
+}
+
+export { }