@voltro/plugin-rooms 0.0.0-stage → 0.87.0

package/dist/geometry.d.ts

@@ -0,0 +1,2249 @@
+import { Context } from 'effect';
+import { Duration } from 'effect';
+import { Effect } from 'effect';
+import { Layer } from 'effect';
+import { Schema } from 'effect';
+import { Subject } from '@voltro/protocol';
+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>;
+
+/** Explicit outside-Tick actual native reconstruction/hash verification. */
+export declare const applyGeometryChunkSnapshot: (offeredBase: GeometryArtifact, offered: GeometryChunkSnapshot, maxPatchBytes?: number, profile?: GeometryArtifactLimits<GeometryKind>) => Promise<GeometryPersistenceObservation>;
+
+/** Pure captured guard/rule preparation. Original profile/identity/layout is
+ * re-admitted after an override; hashing, SQL and native Session belong outside. */
+export declare const applyGeometryEdit: (offered: GeometryEditContext, offeredStrategies?: Partial<GeometryEditStrategies>) => GeometryChunk;
+
+/** Outside-Tick prepare/capture/hash only. Caller supplies actual cache/SQL
+ * revision and authenticated transport/owner authority; this is no mutation ack. */
+export declare const applyGeometryPatch: <C extends GeometryChunk>(before: GeometryArtifact<C>, patch: GeometryPatch, currentRevision: number, codecLimits?: GeometryArtifactLimits<C["kind"]>) => Promise<{
+    readonly artifact: GeometryArtifact<C>;
+    readonly revision: 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 captureGeometryChunkRequest: (root: GeometryPreparedScope, offered: unknown) => GeometryChunkRequest;
+
+export declare const captureGeometryChunkSnapshot: (offered: unknown, maxPatchBytes?: number) => GeometryChunkSnapshot;
+
+export declare const captureGeometryChunkSnapshotFragment: (offered: unknown, maximum?: number) => GeometryChunkSnapshotFragment;
+
+export declare const captureGeometryCompactionStrategies: (offered?: Partial<GeometryCompactionStrategies>) => GeometryCompactionStrategies;
+
+export declare const captureGeometryDeltaFragment: (offered: unknown, options?: {
+    readonly maxPatchBytes?: number | undefined;
+}) => GeometryDeltaFragment;
+
+export declare const captureGeometryDerivationStrategies: (offered?: Partial<GeometryDerivationStrategies>) => GeometryDerivationStrategies;
+
+export declare const captureGeometryEditAuthority: (offered: unknown) => GeometryEditAuthority;
+
+export declare const captureGeometryEditIntent: (offered: unknown) => GeometryEditIntent;
+
+export declare const captureGeometryEditMessage: (offered: unknown) => GeometryEditMessage;
+
+/** Captured pure slots. Unknown/accessor fields and non-void validators refuse. */
+export declare const captureGeometryEditStrategies: (offered?: Partial<GeometryEditStrategies>) => GeometryEditStrategies;
+
+export declare const captureGeometryJournalArchiveReference: (offered: GeometryJournalArchiveReference) => GeometryJournalArchiveReference;
+
+export declare const captureGeometryManifestFragment: (offered: unknown, maximumBytes?: number) => GeometryManifestFragment;
+
+/** Pure source selection only. Actual CMS publication/channel admission is a server capability. */
+export declare const cmsGeometry: (key: string, offered?: {
+    readonly channel?: string | undefined;
+}) => GeometrySource;
+
+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;
+}
+
+/** Compare two published static versions of one World — for example the live channel and a staged preview — so a
+ * GM sees which chunks a promotion would add, remove or change. Chunks compare by `contentSha256`, so a re-encoded
+ * but identical chunk counts as unchanged. Results are sorted by layer set and coordinate. */
+export declare const compareGeometryVersions: (current: GeometryVersionReceipt, next: GeometryVersionReceipt) => GeometryVersionComparison;
+
+/** One current outside-Tick native hash owner over all actual kind codecs. */
+export declare const createGeometryArtifact: <C extends GeometryChunk>(offered: C, limits?: GeometryArtifactLimits<C["kind"]>) => Promise<GeometryArtifact<C>>;
+
+/** Existing GPD net patch against verified static revision0. Current durable SQL
+ * revision is carried separately; this is a read result, not a mutation ACK. */
+export declare const createGeometryChunkSnapshot: (requestId: string, offeredBase: GeometryArtifact, offered: GeometryPersistenceObservation, maxPatchBytes?: number, profile?: GeometryArtifactLimits<GeometryKind>) => Promise<GeometryChunkSnapshot>;
+
+export declare const createGeometryChunkSnapshotFragments: (offered: GeometryChunkSnapshot, maximum?: number) => ReadonlyArray<GeometryChunkSnapshotFragment>;
+
+/** Own actual GPD bytes and exact receipt, then bounded reliable fragments. Never
+ * stream static blobs through this channel or imply that a digest grants rights. */
+export declare const createGeometryDeltaFragments: (offeredReceipt: GeometryPersistenceReceipt, offeredPatch: Uint8Array, options?: {
+    readonly maxPatchBytes?: number | undefined;
+}) => ReadonlyArray<GeometryDeltaFragment>;
+
+/** Canonical quantized height samples over the same genuine RoomStateCodec.
+ * No float quantizer, image/source import, World/provider or native I/O. */
+export declare const createGeometryHeightfieldCodec: (offered?: Partial<GeometryHeightfieldLimits>) => GeometryHeightfieldCodec;
+
+/** Prepare once outside Tick; queries interpolate four admitted raw samples
+ * through the actual fixed math with no source/provider/Store/clock work. */
+export declare const createGeometryHeightfieldView: (offered: GeometryHeightfieldChunk, limits?: Partial<GeometryHeightfieldLimits>) => GeometryHeightfieldView;
+
+/** Actual existing codec-Ops between genuine same-scope captured artifacts.
+ * Producing a data patch allocates no store/authority/lock or player approval. */
+export declare const createGeometryPatch: <C extends GeometryChunk>(before: GeometryArtifact<C>, after: GeometryArtifact<C>, baseRevision: number, options?: {
+    readonly limits?: Partial<GeometryPatchLimits>;
+    readonly codecLimits?: GeometryArtifactLimits<C["kind"]>;
+}) => GeometryPatch;
+
+/** Explicit canonical closed-box/sphere source volumes; not triangle/mesh physics. */
+export declare const createGeometryShapesCodec: (offered?: Partial<GeometryShapesLimits>) => GeometryShapesCodec;
+
+/** Owned fixed-raw volumes, exact unsigned word-square sphere comparisons and
+ * canonical results. Full query budget is required, never a partial empty hit. */
+export declare const createGeometryShapesView: (offered: GeometryShapesChunk, limits?: Partial<GeometryShapesLimits>) => GeometryShapesView;
+
+/** Typed tile convenience facade over the shared actual outside-Tick owner. */
+export declare const createGeometryTileArtifact: (chunk: GeometryTileChunk, limits?: Partial<GeometryTileLimits>) => Promise<GeometryTileArtifact>;
+
+/** One current GTC/v1 envelope over the real RoomStateCodec. Source/client/SQL/
+ * replay consumers can borrow these exact bytes; no storage/host is acquired. */
+export declare const createGeometryTileCodec: (offered?: Partial<GeometryTileLimits>) => GeometryTileCodec;
+
+/** Deterministic four-neighbor A* on one genuine already-compiled immutable tile
+ * view. Admission/large work-array allocation outside Tick, bounded CPU continuation thereafter.
+ * No source/provider callbacks, missing neighbors, diagonal/corner cutting, I/O
+ * or clock. Terminal searches release private work arrays. */
+export declare const createGeometryTilePathSearch: (view: GeometryTileView, start: GeometryTilePoint, goal: GeometryTilePoint, offeredLimits?: Partial<GeometryTileNavigationLimits>) => GeometryTilePathSearch;
+
+/** CPU-only compiled immutable view; perform admission/RLE expansion outside the
+ * tick. Retained O(1) cell queries acquire no source, Store, network or timer. */
+export declare const createGeometryTileView: (offered: GeometryTileChunk, limits?: Partial<GeometryTileLimits>) => GeometryTileView;
+
+/** Canonical global palette and complete ordinal16³ sections; no sparse missing
+ * section/air fallback, source import, World allocation or tick I/O. */
+export declare const createGeometryVoxelCodec: (offered?: Partial<GeometryVoxelLimits>) => GeometryVoxelCodec;
+
+/** Compile cumulative section-run indexes outside Tick. Lookup retains compact
+ * section data rather than expanding a full voxel/material object grid. */
+export declare const createGeometryVoxelView: (offered: GeometryVoxelChunk, limits?: Partial<GeometryVoxelLimits>) => GeometryVoxelView;
+
+/** Prepare a complete rectangular native collision grid outside Tick, then
+ * reuse the real incremental A*. Gaps/profile mismatches refuse. Any genuine
+ * frame replacement/withdrawal cancels even an already-found stale path. */
+export declare const createGeometryWorldTilePathSearch: (view: GeometryWorldView, offeredRegion: GeometryWorldTilePathRegion, offeredStart: GeometryTilePoint, offeredGoal: GeometryTilePoint, offeredOptions?: GeometryWorldTilePathOptions) => GeometryWorldTilePathSearch;
+
+export declare const decodeGeometryInspection: (value: unknown) => GeometryInspection;
+
+/** Admit only complete canonical GPD/v1 envelope/metadata. Opaque codec Ops
+ * require the actual current baseline during apply; no empty baseline is made. */
+export declare const decodeGeometryPatch: (offered: Uint8Array, offeredLimits?: Partial<GeometryPatchLimits>) => GeometryPatch;
+
+/** One exported default. Bounded native canonical codec reconstruction outside
+ * Tick, never accept offered solidity/shape dimensions or full state from a player. */
+export declare const defaultGeometryApplyOp: GeometryEditStrategies['applyOp'];
+
+export declare const defaultGeometryCollisionDerive: GeometryCollisionDerive;
+
+export declare const defaultGeometryCompaction: GeometryCompaction;
+
+export declare const defaultGeometryHeightfieldLimits: Readonly<GeometryHeightfieldLimits>;
+
+/** One exported default, shared by World declaration and actual preparation. */
+export declare const defaultGeometryMigrateDelta: GeometryMigrateDelta;
+
+export declare const defaultGeometryNavDerive: GeometryNavDerive;
+
+/** One exported default. Exact integer-word Euclidean distance: no floating
+ * square approximation, sqrt, I/O or private current-position provider. */
+export declare const defaultGeometryOpValidator: GeometryEditStrategies['opValidator'];
+
+export declare const defaultGeometryPatchLimits: Readonly<GeometryPatchLimits>;
+
+export declare const defaultGeometryRollbackStrategies: Readonly<GeometryRollbackStrategies>;
+
+export declare const defaultGeometryShapesLimits: Readonly<GeometryShapesLimits>;
+
+export declare const defaultGeometryTileLimits: Readonly<GeometryTileLimits>;
+
+export declare const defaultGeometryTileNavigationLimits: Readonly<GeometryTileNavigationLimits>;
+
+export declare const defaultGeometryVoxelLimits: Readonly<GeometryVoxelLimits>;
+
+/** Exact reduced integer ratio over admitted coordinates/differences of magnitude <= u32.
+ * Shared 2D/3D slab arithmetic; never round a fraction before comparing it. */
+export declare interface FixedSlabFraction {
+    readonly numerator: number;
+    readonly denominator: number;
+}
+
+export declare interface GeometryActivation {
+    readonly _tag: 'GeometryActivation';
+    readonly receipt: GeometryPersistenceReceipt;
+}
+
+export 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;
+}
+
+export declare interface GeometryActorInventoryObservation {
+    readonly scope: GeometryPreparedScope;
+    readonly generation: number;
+    readonly chunks: number;
+    readonly accountedBytes: number;
+    readonly closed: boolean;
+}
+
+export 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;
+}
+
+export 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 GeometryBoxOverlapOptions {
+    readonly maxTests?: number;
+}
+
+export declare const GeometryBoxSchema: 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">;
+}>;
+
+export declare interface GeometryCellChunk {
+    readonly coordinate: GeometryPreparedCoordinate;
+    readonly ownerCellId: string;
+    readonly writable: boolean;
+}
+
+export declare interface GeometryCellCoverage {
+    readonly scope: GeometryPreparedScope;
+    readonly cell: WorldCell;
+    readonly marginChunks: number;
+    readonly chunks: ReadonlyArray<GeometryCellChunk>;
+}
+
+export 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;
+    };
+}
+
+export declare type GeometryChunk = GeometryTileChunk | GeometryHeightfieldChunk | GeometryShapesChunk | GeometryVoxelChunk;
+
+export declare type GeometryChunkAddress = (typeof GeometryChunkAddressSchema)["Type"];
+
+export declare type GeometryChunkAddress3D = (typeof GeometryChunkAddress3DSchema)["Type"];
+
+export declare const GeometryChunkAddress3DSchema: Schema.Struct<{
+    readonly worldId: Schema.String;
+    readonly layerSetId: Schema.String;
+    readonly cx: Schema.Int;
+    readonly cy: Schema.Int;
+    readonly cz: Schema.Int;
+}>;
+
+export declare const GeometryChunkAddressSchema: Schema.Struct<{
+    readonly worldId: Schema.String;
+    readonly layerSetId: Schema.String;
+    readonly cx: Schema.Int;
+    readonly cy: Schema.Int;
+}>;
+
+export declare interface GeometryChunkRequest {
+    readonly requestId: string;
+    readonly coordinate: GeometryPreparedCoordinate;
+}
+
+export declare const geometryChunkRequestChannel: Readonly<RoomChannel>;
+
+export declare const GeometryChunkRequestSchema: Schema.Struct<{
+    readonly requestId: Schema.String;
+    readonly coordinate: Schema.Struct<{
+        readonly cx: Schema.Int;
+        readonly cy: Schema.Int;
+        readonly cz: Schema.optional<Schema.Int>;
+    }>;
+}>;
+
+export 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;
+}
+
+export declare const geometryChunkSnapshotChannel: Readonly<RoomChannel>;
+
+export declare interface GeometryChunkSnapshotFragment extends Omit<GeometryChunkSnapshot, 'patch'> {
+    readonly type: 'GeoChunkSnapshotFragment';
+    readonly totalBytes: number;
+    readonly offset: number;
+    readonly bytes: ReadonlyArray<number>;
+}
+
+export declare const GeometryChunkSnapshotFragmentSchema: Schema.Struct<{
+    readonly type: Schema.Literal<"GeoChunkSnapshotFragment">;
+    readonly scope: Schema.Struct<{
+        readonly tenantId: Schema.String;
+        readonly kind: Schema.Literals<readonly ["2d-tiles", "2d-heightfield", "3d-shapes", "3d-voxel"]>;
+        readonly worldId: Schema.String;
+        readonly layerSetId: Schema.String;
+        readonly version: Schema.String;
+        readonly cx: Schema.Int;
+        readonly cy: Schema.Int;
+        readonly cz: Schema.optional<Schema.Int>;
+    }>;
+    readonly requestId: Schema.String;
+    readonly revision: Schema.Int;
+    readonly staticBlobSha256: Schema.String;
+    readonly staticContentSha256: Schema.String;
+    readonly blobSha256: Schema.String;
+    readonly contentSha256: Schema.String;
+    readonly patchSha256: Schema.String;
+    readonly totalBytes: Schema.Int;
+    readonly offset: Schema.Int;
+    readonly bytes: Schema.$Array<Schema.Int>;
+}>;
+
+export declare type GeometryCollisionDerive = (context: GeometryDerivationContext) => GeometryChunk;
+
+export 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. */
+export declare interface GeometryCompactionContext {
+    readonly static: GeometryArtifact;
+    readonly current: GeometryArtifact;
+    readonly limits: GeometryPatchLimits;
+    readonly codecLimits: GeometryArtifactLimits<GeometryKind>;
+}
+
+export declare interface GeometryCompactionStrategies {
+    readonly compaction: GeometryCompaction;
+}
+
+export declare interface GeometryDeltaFragment {
+    readonly type: 'GeoDeltaFragment';
+    readonly receipt: GeometryPersistenceReceipt;
+    readonly totalBytes: number;
+    readonly offset: number;
+    readonly bytes: ReadonlyArray<number>;
+}
+
+export declare const geometryDeltaFragmentBytes = 8192;
+
+/** Existing ordinary Room ServerMessage codec, no new wire frame or second Delta format. */
+export declare const GeometryDeltaFragmentSchema: Schema.Struct<{
+    readonly type: Schema.Literal<"GeoDeltaFragment">;
+    readonly receipt: Schema.Struct<{
+        readonly scope: Schema.Struct<{
+            readonly tenantId: Schema.String;
+            readonly kind: Schema.Literals<readonly ["2d-tiles", "2d-heightfield", "3d-shapes", "3d-voxel"]>;
+            readonly worldId: Schema.String;
+            readonly version: Schema.String;
+            readonly layerSetId: Schema.String;
+            readonly cx: Schema.Int;
+            readonly cy: Schema.Int;
+            readonly cz: Schema.optional<Schema.Int>;
+        }>;
+        readonly requestId: Schema.String;
+        readonly baseRevision: Schema.Int;
+        readonly revision: Schema.Int;
+        readonly changed: Schema.Boolean;
+        readonly blobSha256: Schema.String;
+        readonly contentSha256: Schema.String;
+    }>;
+    readonly totalBytes: Schema.Int;
+    readonly offset: Schema.Int;
+    readonly bytes: Schema.$Array<Schema.Int>;
+}>;
+
+export declare interface GeometryDeltaMigrationFrom {
+    readonly static: GeometryArtifact;
+    readonly current: GeometryArtifact;
+    readonly revision: number;
+}
+
+export declare interface GeometryDeltaMigrationTo {
+    readonly static: GeometryArtifact;
+}
+
+export declare interface GeometryDeltaReceiver {
+    receive(fragment: unknown): GeometryDeltaReception;
+    drop(scope: GeometryPersistenceScope, requestId: string): boolean;
+    reset(): void;
+    observation(): {
+        readonly pending: number;
+        readonly accountedBytes: number;
+    };
+}
+
+export declare interface GeometryDeltaReceiverOptions {
+    readonly maxPending?: number | undefined;
+    readonly maxPatchBytes?: number | undefined;
+    readonly maxPendingBytes?: number | undefined;
+}
+
+export declare type GeometryDeltaReception = {
+    readonly _tag: 'pending';
+    readonly receivedFragments: number;
+    readonly totalFragments: number;
+} | {
+    readonly _tag: 'complete';
+    readonly receipt: GeometryPersistenceReceipt;
+    readonly patch: Uint8Array;
+};
+
+/** Outside-Tick native data only. No query callback, provider, actor, Store or
+ * authority capability is accepted as a derivation result. */
+export declare interface GeometryDerivationContext {
+    readonly chunk: GeometryChunk;
+    readonly codecLimits: GeometryArtifactLimits<GeometryKind>;
+}
+
+export declare interface GeometryDerivationStrategies {
+    readonly collisionDerive: GeometryCollisionDerive;
+    readonly navDerive: GeometryNavDerive;
+}
+
+/** Trusted server snapshot. Never derive these rights, positions, budgets or
+ * catalogs from the intent body. App policy must recheck authority at commit. */
+export 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>;
+}
+
+export declare const geometryEditChannel: Readonly<RoomChannel>;
+
+export declare interface GeometryEditContext {
+    readonly chunk: GeometryChunk;
+    readonly intent: GeometryEditIntent;
+    readonly authority: GeometryEditAuthority;
+    readonly placementId: string;
+    readonly codecLimits?: GeometryArtifactLimits<GeometryKind> | undefined;
+}
+
+/** Player requests an action and its target, never solidity, shape dimensions,
+ * an authoritative player position, revision, owner, full chunk or Delta bytes. */
+export 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;
+};
+
+export declare interface GeometryEditMessage {
+    readonly requestId: string;
+    readonly coordinate: GeometryPreparedCoordinate;
+    readonly intent: GeometryEditIntent;
+}
+
+/** Ordinary reliable ClientMessage: action/target/identity, no player authority,
+ * state, revision, patch, Subject, owner epoch or geometry-source selector. */
+export declare const GeometryEditMessageSchema: Schema.Struct<{
+    readonly requestId: Schema.String;
+    readonly coordinate: Schema.Struct<{
+        readonly cx: Schema.Int;
+        readonly cy: Schema.Int;
+        readonly cz: Schema.optional<Schema.Int>;
+    }>;
+    readonly intent: Schema.Union<readonly [Schema.Struct<{
+        readonly op: Schema.Literal<"setTile">;
+        readonly x: Schema.Int;
+        readonly y: Schema.Int;
+        readonly material: Schema.String;
+    }>, Schema.Struct<{
+        readonly op: Schema.Literal<"raiseHeight">;
+        readonly x: Schema.Int;
+        readonly y: Schema.Int;
+        readonly units: Schema.Int;
+    }>, Schema.Struct<{
+        readonly op: Schema.Literal<"setVoxel">;
+        readonly x: Schema.Int;
+        readonly y: Schema.Int;
+        readonly z: Schema.Int;
+        readonly material: Schema.String;
+    }>, Schema.Struct<{
+        readonly op: Schema.Literal<"placeShape">;
+        readonly template: Schema.String;
+        readonly xRaw: Schema.Int;
+        readonly yRaw: Schema.Int;
+        readonly zRaw: Schema.Int;
+    }>, Schema.Struct<{
+        readonly op: Schema.Literal<"removeShape">;
+        readonly id: Schema.String;
+    }>]>;
+}>;
+
+export 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;
+}
+
+export declare type GeometryGenerator = (context: GeometryProceduralContext) => GeometryChunk;
+
+export declare interface GeometryGltfImportOptions {
+    readonly worldId: string;
+    readonly layerSetId: string;
+    readonly version: string;
+    readonly origin: {
+        readonly cx: number;
+        readonly cy: number;
+        readonly cz: number;
+    };
+    /** Complete authored volume, including explicitly empty output chunks. */
+    readonly chunks: {
+        readonly x: number;
+        readonly y: number;
+        readonly z: number;
+    };
+    readonly chunkSizeRaw?: number;
+    readonly scene: number;
+    readonly collisionNodes: ReadonlyArray<number>;
+    /** Explicit conservative mesh bounding volumes, not triangle collision. */
+    readonly collision: 'mesh-aabb';
+    /** Exact buffer-index order; no URI/file/network resolution. */
+    readonly buffers: ReadonlyArray<Uint8Array>;
+    readonly maxInputBytes?: number;
+    readonly maxBufferBytes?: number;
+    readonly maxNodes?: number;
+    readonly maxVertices?: number;
+    readonly maxChunks?: number | undefined;
+    readonly maxShapes?: number;
+    readonly codecLimits?: Partial<GeometryShapesLimits> | undefined;
+}
+
+export 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;
+}
+
+export declare interface GeometryGridRayOptions {
+    readonly maxVisitedCells?: number;
+}
+
+export declare interface GeometryGridRayPoint {
+    readonly xRaw: number;
+    readonly yRaw: number;
+    readonly zRaw?: number;
+}
+
+export 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. */
+export declare interface GeometryHeightfieldBoxRaw {
+    readonly minXRaw: number;
+    readonly minYRaw: number;
+    readonly minZRaw: number;
+    readonly maxXRaw: number;
+    readonly maxYRaw: number;
+    readonly maxZRaw: number;
+}
+
+export declare type GeometryHeightfieldChunk = (typeof GeometryHeightfieldChunkSchema)["Type"];
+
+export 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>;
+}>;
+
+export declare interface GeometryHeightfieldCodec {
+    readonly limits: GeometryHeightfieldLimits;
+    readonly schemaHash: number;
+    capture(offered: unknown): GeometryHeightfieldChunk;
+    create(source: GeometryHeightfieldSource): GeometryHeightfieldChunk;
+    encode(chunk: GeometryHeightfieldChunk): Uint8Array;
+    decode(bytes: Uint8Array): GeometryHeightfieldChunk;
+}
+
+export declare interface GeometryHeightfieldLimits {
+    readonly maxSide: number;
+    readonly maxSamples: number;
+    readonly maxBytes: number;
+}
+
+export 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;
+}
+
+export declare interface GeometryHeightfieldRayOptions {
+    /** Distance between coarse samples along the ground track, in raw units (e.g. a quarter of the sample spacing). */
+    readonly stepRaw: number;
+    /** Height samples the ray may read, coarse and refining together. */
+    readonly maxSamples: number;
+}
+
+export declare interface GeometryHeightfieldRayPoint {
+    readonly xRaw: number;
+    readonly yRaw: number;
+    readonly zRaw: number;
+}
+
+/** The surface under one global raw point: the native interpolated height and the chunk it came from. */
+export declare interface GeometryHeightfieldSample {
+    readonly heightRaw: number;
+    readonly scope: GeometryPersistenceScope;
+    readonly revision: number;
+}
+
+export declare interface GeometryHeightfieldSource {
+    readonly address: GeometryChunkAddress;
+    readonly version: string;
+    readonly width: number;
+    readonly height: number;
+    readonly sampleSpacingRaw: number;
+    readonly baseHeightRaw: number;
+    readonly heightQuantumRaw: number;
+    readonly heightRawSamples: ReadonlyArray<number>;
+}
+
+export 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;
+}
+
+export declare interface GeometryHeightfieldSweepOptions {
+    /** Coarse step along the longest axis, in raw units (for example a quarter of the sample spacing). */
+    readonly stepRaw: number;
+    /** Overlap evaluations the sweep may use. */
+    readonly maxEvaluations: number;
+}
+
+export declare interface GeometryHeightfieldView {
+    readonly chunk: GeometryHeightfieldChunk;
+    heightAtSample(x: number, y: number): number;
+    heightAtRaw(xRaw: number, yRaw: number): number;
+}
+
+export declare interface GeometryHeightRollbackContext {
+    readonly key: string;
+    readonly before: number;
+    readonly after: number;
+    readonly selected: number;
+    readonly target: boolean;
+}
+
+export declare type GeometryInspection = typeof GeometryInspectionSchema.Type;
+
+export declare interface GeometryInspectionQuery {
+    readonly tenantId: string;
+    readonly table?: GeometryInspectionTable;
+    readonly after?: string | null;
+}
+
+/** Read-only configured budgets and paged recorded metadata. No Subject, owner,
+ * request, credential, lease, hashes, source locator or chunk/patch payload. */
+export declare const GeometryInspectionSchema: Schema.Struct<{
+    readonly installed: Schema.Boolean;
+    readonly sourceBound: Schema.Boolean;
+    readonly migrationsInstalled: Schema.Boolean;
+    readonly assetUrlsInstalled: Schema.Boolean;
+    readonly archivesInstalled: Schema.Boolean;
+    readonly retentionInstalled: Schema.Boolean;
+    readonly adminControlsInstalled: Schema.Boolean;
+    readonly page: Schema.Struct<{
+        readonly tenantId: Schema.String;
+        readonly table: Schema.Literals<readonly ["versions", "deltas", "journal", "migrations", "archives"]>;
+        readonly after: Schema.NullOr<Schema.String>;
+        readonly nextAfter: Schema.NullOr<Schema.String>;
+    }>;
+    readonly configuration: Schema.$Array<Schema.Struct<{
+        readonly worldId: Schema.String;
+        readonly kind: Schema.Literals<readonly ["2d-tiles", "2d-heightfield", "3d-shapes", "3d-voxel"]>;
+        readonly staticSource: Schema.Literals<readonly ["cms", "imported", "procedural"]>;
+        readonly chunkSizeRaw: Schema.Number;
+        readonly dynamicEnabled: Schema.Boolean;
+        readonly migrationStrategy: Schema.Literals<readonly ["default", "custom"]>;
+        readonly compactionStrategy: Schema.Literals<readonly ["default", "custom"]>;
+        readonly collisionDeriveStrategy: Schema.Literals<readonly ["default", "custom"]>;
+        readonly navDeriveStrategy: Schema.Literals<readonly ["default", "custom"]>;
+        readonly opValidatorStrategy: Schema.Literals<readonly ["default", "custom"]>;
+        readonly applyOpStrategy: Schema.Literals<readonly ["default", "custom"]>;
+        readonly overlapTestBudget: Schema.Number;
+        readonly rayCellBudget: Schema.Number;
+        readonly deltaByteBudget: Schema.Number;
+        readonly preparedChunkBudget: Schema.Number;
+        readonly preparedByteBudget: Schema.Number;
+        readonly marginChunks: Schema.Number;
+    }>>;
+    readonly rows: Schema.$Array<Schema.Struct<{
+        readonly id: Schema.String;
+        readonly worldId: Schema.String;
+        readonly kind: Schema.Literals<readonly ["2d-tiles", "2d-heightfield", "3d-shapes", "3d-voxel"]>;
+        readonly version: Schema.String;
+        readonly coordinates: Schema.NullOr<Schema.Struct<{
+            readonly cx: Schema.Int;
+            readonly cy: Schema.Int;
+            readonly cz: Schema.optional<Schema.Int>;
+        }>>;
+        readonly revision: Schema.NullOr<Schema.Number>;
+        readonly changed: Schema.NullOr<Schema.Boolean>;
+        readonly manifestChunks: Schema.NullOr<Schema.Number>;
+        readonly migration: Schema.NullOr<Schema.Struct<{
+            readonly fromVersion: Schema.String;
+            readonly fromRevision: Schema.Number;
+            readonly decision: Schema.Literals<readonly ["kept", "discarded", "custom"]>;
+            readonly staticChanged: Schema.Boolean;
+        }>>;
+        readonly observedAt: Schema.String;
+    }>>;
+}>;
+
+export declare type GeometryInspectionTable = typeof GeometryInspectionTableSchema.Type;
+
+export declare const GeometryInspectionTableSchema: Schema.Literals<readonly ["versions", "deltas", "journal", "migrations", "archives"]>;
+
+export declare interface GeometryJournalArchiveReference {
+    readonly receipt: GeometryPersistenceReceipt;
+    readonly patchSha256: string;
+    readonly size: number;
+}
+
+export declare type GeometryKind = GeometryChunk['kind'];
+
+export declare interface GeometryManifestFragment {
+    readonly type: 'GeoManifestFragment';
+    readonly scope: GeometryPreparedScope;
+    readonly payloadSha256: string;
+    readonly totalBytes: number;
+    readonly offset: number;
+    readonly bytes: ReadonlyArray<number>;
+}
+
+export declare const geometryManifestFragmentBytes = 8192;
+
+export declare const GeometryManifestFragmentSchema: Schema.Struct<{
+    readonly type: Schema.Literal<"GeoManifestFragment">;
+    readonly scope: Schema.Struct<{
+        readonly tenantId: Schema.String;
+        readonly kind: Schema.Literals<readonly ["2d-tiles", "2d-heightfield", "3d-shapes", "3d-voxel"]>;
+        readonly worldId: Schema.String;
+        readonly layerSetId: Schema.String;
+        readonly version: Schema.String;
+    }>;
+    readonly payloadSha256: Schema.String;
+    readonly totalBytes: Schema.Int;
+    readonly offset: Schema.Int;
+    readonly bytes: Schema.$Array<Schema.Int>;
+}>;
+
+export declare interface GeometryManifestReceiverOptions {
+    readonly maxManifestBytes?: number;
+    readonly maxPending?: number | undefined;
+    readonly maxPendingBytes?: number | undefined;
+}
+
+export declare const geometryManifestReliableChannel: Readonly<RoomChannel>;
+
+/** Pure native data rule only; no SQL, actor, journal, permission or Subject. */
+export declare type GeometryMigrateDelta = (from: GeometryDeltaMigrationFrom, to: GeometryDeltaMigrationTo) => GeometryChunk | null;
+
+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 type GeometryNavDerive = (context: GeometryDerivationContext) => GeometryTileChunk | null;
+
+export declare interface GeometryPatch {
+    readonly metadata: GeometryPatchMetadata;
+    bytes(): Uint8Array;
+}
+
+export declare interface GeometryPatchLimits {
+    readonly maxBytes: number;
+    readonly maxMetadataBytes: number;
+}
+
+export declare type GeometryPatchMetadata = (typeof GeometryPatchMetadataSchema)["Type"];
+
+export 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 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>;
+}>;
+
+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 GeometryPersistenceSubject {
+    readonly id: string;
+    readonly kind: 'user' | 'guest';
+}
+
+export declare interface GeometryPointRaw3D {
+    readonly xRaw: number;
+    readonly yRaw: number;
+    readonly zRaw: number;
+}
+
+export declare interface GeometryPreparedCoordinate {
+    readonly cx: number;
+    readonly cy: number;
+    readonly cz?: number | undefined;
+}
+
+export 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;
+};
+
+export 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 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;
+}
+
+export declare interface GeometryPreparedScope {
+    readonly tenantId: string;
+    readonly kind: GeometryKind;
+    readonly worldId: string;
+    readonly layerSetId: string;
+    readonly version: string;
+}
+
+export 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;
+}
+
+export declare interface GeometryProceduralContext {
+    readonly seed: number;
+    readonly kind: GeometryKind;
+    readonly address: GeometryChunk['address'];
+    readonly version: string;
+}
+
+export declare const geometryReliableChannel: Readonly<RoomChannel>;
+
+export declare interface GeometryRollbackEntry {
+    readonly subject: GeometryPersistenceSubject;
+    readonly patch: Uint8Array;
+}
+
+export 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;
+}
+
+export declare interface GeometryRollbackPreparation {
+    readonly artifact: GeometryArtifact;
+    readonly patch: GeometryPatch;
+    readonly revision: number;
+    readonly entries: number;
+    readonly targetEntries: number;
+    readonly restoredCells: number;
+}
+
+export 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;
+}
+
+export declare type GeometryShape = (typeof GeometryShapeSchema)["Type"];
+
+export 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;
+}
+
+export 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">;
+}>]>;
+
+export declare type GeometryShapesChunk = (typeof GeometryShapesChunkSchema)["Type"];
+
+export 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">;
+    }>]>>;
+}>;
+
+export declare interface GeometryShapesCodec {
+    readonly limits: GeometryShapesLimits;
+    readonly schemaHash: number;
+    capture(offered: unknown): GeometryShapesChunk;
+    create(source: GeometryShapesSource): GeometryShapesChunk;
+    encode(chunk: GeometryShapesChunk): Uint8Array;
+    decode(bytes: Uint8Array): GeometryShapesChunk;
+}
+
+export declare interface GeometryShapesLimits {
+    readonly maxShapes: number;
+    readonly maxBytes: number;
+}
+
+export declare interface GeometryShapesSource {
+    readonly address: GeometryChunkAddress3D;
+    readonly version: string;
+    readonly extentXRaw: number;
+    readonly extentYRaw: number;
+    readonly extentZRaw: number;
+    readonly shapes: ReadonlyArray<GeometryShape>;
+}
+
+export 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>;
+}
+
+export 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 GeometrySnapshotReceiverOptions {
+    readonly maxPatchBytes?: number | undefined;
+    readonly maxPending?: number | undefined;
+    readonly maxPendingBytes?: number | undefined;
+}
+
+export 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;
+};
+
+export declare const GeometrySphereSchema: 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">;
+}>;
+
+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 GeometrySubjectOperation {
+    readonly receipt: GeometryPersistenceReceipt;
+    readonly patch: Uint8Array;
+}
+
+export declare interface GeometryTileArtifact {
+    readonly chunk: GeometryTileChunk;
+    readonly blobSha256: string;
+    readonly tileDataSha256: string;
+    bytes(): Uint8Array;
+}
+
+export declare interface GeometryTileCellBounds {
+    readonly minXRaw: number;
+    readonly minYRaw: number;
+    readonly maxXRaw: number;
+    readonly maxYRaw: number;
+}
+
+export declare type GeometryTileChunk = (typeof GeometryTileChunkSchema)["Type"];
+
+export 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;
+    }>>;
+}>;
+
+export declare interface GeometryTileChunkSource {
+    readonly address: GeometryChunkAddress;
+    readonly version: string;
+    readonly width: number;
+    readonly height: number;
+    readonly tileSizeRaw: number;
+    readonly cells: ReadonlyArray<GeometryTileMaterial>;
+}
+
+export declare interface GeometryTileCodec {
+    readonly schemaHash: number;
+    readonly limits: GeometryTileLimits;
+    /** Canonical RLE/material admission; does not normalize malformed carriers. */
+    capture(offered: unknown): GeometryTileChunk;
+    /** Construct one canonical palette/RLE representation from owned row-major data. */
+    create(source: GeometryTileChunkSource): GeometryTileChunk;
+    encode(chunk: GeometryTileChunk): Uint8Array;
+    decode(bytes: Uint8Array): GeometryTileChunk;
+}
+
+export 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;
+}
+
+export declare interface GeometryTileImportMaterial {
+    readonly sourceId: number;
+    /** LDtk tile flip bits (0–3); Tiled uses its entire unsigned GID as sourceId. */
+    readonly flip?: number;
+    readonly material: GeometryTileMaterial;
+}
+
+export declare interface GeometryTileImportOptions {
+    readonly worldId: string;
+    readonly layerSetId: string;
+    readonly version: string;
+    /** Explicit author placement in global tile coordinates. */
+    readonly origin: {
+        readonly x: number;
+        readonly y: number;
+    };
+    readonly chunkSide?: number;
+    readonly tileSizeRaw?: number;
+    readonly materials: ReadonlyArray<GeometryTileImportMaterial>;
+    readonly maxInputBytes?: number;
+    readonly maxCells?: number | undefined;
+    readonly maxRegions?: number;
+    readonly maxChunks?: number | undefined;
+    readonly codecLimits?: Partial<GeometryTileLimits> | undefined;
+}
+
+export declare interface GeometryTileLimits {
+    readonly maxSide: number;
+    readonly maxCells: number;
+    readonly maxPalette: number;
+    readonly maxRuns: number;
+    readonly maxBytes: number;
+}
+
+export declare type GeometryTileMaterial = (typeof GeometryTileMaterialSchema)["Type"];
+
+export declare const GeometryTileMaterialSchema: Schema.Struct<{
+    readonly key: Schema.String;
+    readonly solid: Schema.Boolean;
+}>;
+
+export declare interface GeometryTileNavigationLimits {
+    readonly maxDiscovered: number;
+    readonly maxOpen: number;
+    readonly maxPathLength: number;
+    readonly maxAdvanceExpansions: number;
+}
+
+export declare interface GeometryTilePathMetrics {
+    readonly discovered: number;
+    readonly expanded: number;
+    readonly traced: number;
+    readonly open: number;
+    readonly pathLength: number;
+}
+
+export declare interface GeometryTilePathSearch {
+    readonly status: GeometryTilePathStatus;
+    readonly metrics: GeometryTilePathMetrics;
+    /** Terminal found path only; no partial-path success on exhaustion. */
+    readonly path: ReadonlyArray<GeometryTilePoint> | null;
+    /** Shared node-expansion/parent-trace quota; no measured navBudgetMs claim. */
+    advance(maximumExpansions?: number): GeometryTilePathStatus;
+    cancel(): void;
+}
+
+export declare type GeometryTilePathStatus = 'pending' | 'found' | 'unreachable' | 'budget-exhausted' | 'cancelled';
+
+export declare interface GeometryTilePoint {
+    readonly x: number;
+    readonly y: number;
+}
+
+export declare type GeometryTileRun = (typeof GeometryTileRunSchema)["Type"];
+
+export declare const GeometryTileRunSchema: Schema.Struct<{
+    readonly paletteIndex: Schema.Int;
+    readonly length: Schema.Int;
+}>;
+
+export 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;
+}
+
+export declare interface GeometryVersionActivation {
+    readonly _tag: 'GeometryVersionActivation';
+    readonly receipts: ReadonlyArray<GeometryMigrationReceipt>;
+}
+
+/** One chunk address: layer set and chunk coordinate. */
+export declare interface GeometryVersionChunkAddress {
+    readonly layerSetId: string;
+    readonly cx: number;
+    readonly cy: number;
+    readonly cz?: number | undefined;
+}
+
+/** What replacing `current` by `next` changes, chunk by chunk (by content hash, not blob bytes). */
+export declare interface GeometryVersionComparison {
+    readonly added: ReadonlyArray<GeometryVersionChunkAddress>;
+    readonly removed: ReadonlyArray<GeometryVersionChunkAddress>;
+    readonly changed: ReadonlyArray<GeometryVersionChunkAddress>;
+    readonly unchanged: number;
+}
+
+export declare interface GeometryVersionMigrationStrategies {
+    readonly migrateDelta?: GeometryMigrateDelta;
+}
+
+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>;
+}
+
+export declare type GeometryVoxelChunk = (typeof GeometryVoxelChunkSchema)["Type"];
+
+export 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;
+        }>>;
+    }>>;
+}>;
+
+export declare interface GeometryVoxelCodec {
+    readonly limits: GeometryVoxelLimits;
+    readonly schemaHash: number;
+    capture(offered: unknown): GeometryVoxelChunk;
+    create(source: GeometryVoxelSource): GeometryVoxelChunk;
+    encode(chunk: GeometryVoxelChunk): Uint8Array;
+    decode(bytes: Uint8Array): GeometryVoxelChunk;
+}
+
+export declare interface GeometryVoxelLimits {
+    readonly maxSide: number;
+    readonly maxVoxels: number;
+    readonly maxPalette: number;
+    readonly maxSections: number;
+    readonly maxRunsPerSection: number;
+    readonly maxBytes: number;
+}
+
+export declare type GeometryVoxelSection = (typeof GeometryVoxelSectionSchema)["Type"];
+
+export declare const GeometryVoxelSectionSchema: 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;
+    }>>;
+}>;
+
+export declare interface GeometryVoxelSource {
+    readonly address: GeometryChunkAddress3D;
+    readonly version: string;
+    readonly side: number;
+    readonly voxelSizeRaw: number;
+    readonly voxels: ReadonlyArray<GeometryTileMaterial>;
+}
+
+export 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;
+}
+
+export declare interface GeometryVoxImportOptions {
+    readonly worldId: string;
+    readonly layerSetId: string;
+    readonly version: string;
+    readonly origin: {
+        readonly cx: number;
+        readonly cy: number;
+        readonly cz: number;
+    };
+    /** VOX gravity axis is Z. Explicitly retain XYZ or swap Y/Z; never infer engine axes. */
+    readonly axes: 'xyz' | 'xzy';
+    readonly chunkSide?: number;
+    readonly voxelSizeRaw?: number;
+    readonly modelIndex?: number;
+    readonly emptyMaterial: GeometryTileMaterial;
+    readonly materials: ReadonlyArray<{
+        readonly colorIndex: number;
+        readonly material: GeometryTileMaterial;
+    }>;
+    readonly maxInputBytes?: number;
+    readonly maxVoxels?: number;
+    readonly maxChunks?: number | undefined;
+    readonly maxFileChunks?: number;
+    readonly codecLimits?: Partial<GeometryVoxelLimits> | undefined;
+}
+
+/** Nonempty half-open raw box. Three-dimensional kinds require both Z fields. */
+export declare interface GeometryWorldBoxRaw {
+    readonly minXRaw: number;
+    readonly minYRaw: number;
+    readonly maxXRaw: number;
+    readonly maxYRaw: number;
+    readonly minZRaw?: number;
+    readonly maxZRaw?: number;
+}
+
+export declare interface GeometryWorldPointRaw {
+    readonly xRaw: number;
+    readonly yRaw: number;
+    readonly zRaw?: number;
+}
+
+export declare type GeometryWorldRayHit = GeometryGridRayHit | GeometryShapeRayHit | GeometryHeightfieldRayHit;
+
+export declare interface GeometryWorldRayOptions extends GeometryGridRayOptions {
+    /** Shapes only; narrows maxOverlapTests for the total shape scan. */
+    readonly maxTests?: number;
+}
+
+export declare interface GeometryWorldShapeHit {
+    readonly scope: GeometryPersistenceScope;
+    readonly revision: number;
+    readonly shape: GeometryShape;
+}
+
+export declare interface GeometryWorldTilePathOptions extends Partial<GeometryTileNavigationLimits> {
+    readonly maxRegionCells?: number;
+}
+
+export declare interface GeometryWorldTilePathRegion {
+    readonly minCx: number;
+    readonly minCy: number;
+    readonly chunksX: number;
+    readonly chunksY: number;
+}
+
+export declare interface GeometryWorldTilePathSearch {
+    readonly status: GeometryTilePathStatus;
+    readonly metrics: GeometryTilePathMetrics;
+    /** Global TILE coordinates; only terminal current found paths are returned. */
+    readonly path: ReadonlyArray<GeometryTilePoint> | null;
+    advance(maximumExpansions?: number): GeometryTilePathStatus;
+    cancel(): void;
+}
+
+export 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;
+}
+
+/** App-root relative declaration; it neither opens a path nor proves filesystem custody. */
+export declare const importedGeometry: (directory: string) => GeometrySource;
+
+/** Pure glTF2 JSON + supplied binary buffers -> explicitly selected conservative
+ * axis-aligned collision bounds. Real POSITION bytes, metadata bounds checked,
+ * exact native fixed values. Never silently promote render meshes to physics. */
+export declare const importGltfGeometry: (offered: Uint8Array, options: GeometryGltfImportOptions) => ReadonlyArray<GeometryShapesChunk>;
+
+/** Import one explicit embedded or supplied standalone LDtk level/layer. Layer
+ * offsets are respected; author origin is explicit, independent of world layout.
+ * External files are never followed and stacked visual tiles never pick a winner. */
+export declare const importLdtkGeometry: (bytes: Uint8Array, options: LdtkGeometryImportOptions) => ReadonlyArray<GeometryTileChunk>;
+
+/** Import one explicit orthogonal JSON tile layer, with finite data or infinite
+ * chunks. No external asset access, compression, default padding or SQL. */
+export declare const importTiledGeometry: (bytes: Uint8Array, options: TiledGeometryImportOptions) => ReadonlyArray<GeometryTileChunk>;
+
+/** Pure offline VOX150 model import. Exact native 16³-section geometry, explicit
+ * empty/color semantics. Scene-graph transforms/animations refuse; no palette
+ * color is guessed to be solid and no authored SIZE volume is padded. */
+export declare const importVoxGeometry: (offered: Uint8Array, options: GeometryVoxImportOptions) => ReadonlyArray<GeometryVoxelChunk>;
+
+export declare interface LdtkGeometryImportOptions extends GeometryTileImportOptions {
+    readonly level: string;
+    readonly layer: string;
+    /** Tiles/AutoLayer must explicitly represent uncovered cells. IntGrid maps zero. */
+    readonly emptyMaterial?: GeometryTileMaterial;
+    /** Select a multi-world project's exact world iid. */
+    readonly worldIid?: string;
+}
+
+/** Native prepared capabilities only. This does not install itself into Room hooks or establish owner/session authority. */
+export declare const makeGeometryActorInventory: (offered: GeometryPreparedInventory) => GeometryActorInventory;
+
+/** CPU owned reassembly only; real Room admission/view authorization is the
+ * caller's boundary. No automatic application, prediction or remote ACK. */
+export declare const makeGeometryDeltaReceiver: (offered?: GeometryDeltaReceiverOptions) => GeometryDeltaReceiver;
+
+/** Native message carrier reassembly only. Caller must verify actual payload SHA
+ * and canonical metadata/root, outside the synchronous reliable callback. */
+export declare const makeGeometryManifestReceiver: (offered?: GeometryManifestReceiverOptions) => Readonly<{
+    receive: (offered: unknown) => Readonly<{
+        scope: GeometryPreparedScope;
+        payloadSha256: string;
+        bytes: Uint8Array<ArrayBuffer>;
+    }> | null;
+    reset: () => void;
+    observation: () => Readonly<{
+        pending: number;
+        accountedBytes: number;
+    }>;
+}>;
+
+/** Same bounded byte carrier reassembly as native manifests, then actual GPD
+ * metadata capture. Caller still performs actual patch SHA/native application. */
+export declare const makeGeometrySnapshotReceiver: (offered?: GeometrySnapshotReceiverOptions) => Readonly<{
+    receive: (offered: unknown) => GeometryChunkSnapshot | null;
+    drop: (scope: GeometryPersistenceScope, requestId: string) => boolean;
+    reset: () => void;
+    observation: () => Readonly<{
+        pending: number;
+        accountedBytes: number;
+    }>;
+}>;
+
+/** CPU-only global coordinate facade over the current genuine actor frame.
+ * No structural callbacks, source, Store, hash, worker, timer or transport work.
+ * Native pointer activation is visible on the next synchronous query. */
+export declare const makeGeometryWorldView: (offeredWorld: AnyWorldDescriptor, actor: GeometryActorInventory) => GeometryWorldView;
+
+declare class NotRoomMember extends NotRoomMember_base {
+}
+
+declare const NotRoomMember_base: Schema.Class<NotRoomMember, Schema.TaggedStruct<"NotRoomMember", {
+    readonly sessionId: Schema.String;
+}>, YieldableError>;
+
+/** Terrain is solid at and below its surface: does the half-open box reach under the surface anywhere? It does
+ * exactly when the highest surface point over its footprint is at or above `minZRaw`. `surface` answers the
+ * native interpolated height at one global raw point (and refuses unloaded coordinates); `spacingRaw` is the
+ * sample spacing shared by every chunk. At most `maxTests` surface samples are read. */
+export declare const overlapsGeometryHeightfieldBox: (offered: GeometryHeightfieldBoxRaw, surface: (xRaw: number, yRaw: number) => number, spacingRaw: number, maxTests: number) => boolean;
+
+declare interface PreparedCommon {
+    readonly scope: GeometryPersistenceScope;
+    readonly revision: number;
+    readonly blobSha256: string;
+    readonly contentSha256: string;
+    readonly accountedBytes: number;
+}
+
+/** Outside Tick and before SQL CAS. Reconstruct the selected genuine native
+ * output under original caps, not merely declared hashes or a structural codec. */
+export declare const prepareGeometryCompaction: (offered: GeometryCompactionContext, offeredStrategies?: Partial<GeometryCompactionStrategies>) => Promise<GeometryPatch>;
+
+/** Outside-Tick full logical/encoded profile admission and native view allocation.
+ * Retains genuine artifacts privately; public entries expose actual synchronous
+ * native query capabilities, never structural providers or source callbacks. */
+export declare const prepareGeometryInventory: (offeredRoot: GeometryPreparedScope, observations: ReadonlyArray<GeometryPersistenceObservation>, offered?: GeometryPreparedOptions) => GeometryPreparedInventory;
+
+/** Outside-Tick native preparation only. Trusted SQL caller supplies a complete
+ * ordered journal and its authentic Subject attribution. No authority, lease,
+ * SQL write, player state upload or receipt is inferred by this pure owner.
+ * Remove target's changed cells while preserving later peer changes. No-op
+ * patches cannot establish a new semantic writer and remain no-ops. */
+export declare const prepareGeometryRollback: (offeredBaseline: GeometryArtifact, baseRevision: number, offeredCurrent: GeometryArtifact, currentRevision: number, offeredEntries: ReadonlyArray<GeometryRollbackEntry>, offeredTarget: GeometryPersistenceSubject | null, offered?: GeometryRollbackOptions) => Promise<GeometryRollbackPreparation>;
+
+/** Captured author callback only, never invoked during World declaration/catalogue admission. */
+export declare const procedural: (offered: {
+    readonly seed: number;
+    readonly generator: GeometryGenerator;
+}) => GeometrySource;
+
+declare class ProtocolError extends ProtocolError_base {
+    get message(): string;
+}
+
+declare const ProtocolError_base: Schema.Class<ProtocolError, Schema.TaggedStruct<"ProtocolError", {
+    readonly detail: Schema.String;
+}>, YieldableError>;
+
+/** Deterministic heightfield ray: sample the segment at fixed steps along its ground track and
+ * take the first step at or below the surface (`z <= height`), then halve that step until it is
+ * one raw unit long. Points are floored onto the raw grid (so a hit can come up to one raw unit
+ * early), and every engine that runs the same native interpolation gets the same hit. A surface crossed and re-crossed within one coarse step
+ * can be missed: the step length is the contract's resolution. Missing chunks or an exhausted
+ * sample budget refuse rather than publish a partial answer; a segment that starts below the
+ * surface hits at fraction 0. */
+export declare const raycastGeometryHeightfield: (offeredFrom: GeometryHeightfieldRayPoint, offeredTo: GeometryHeightfieldRayPoint, sample: (xRaw: number, yRaw: number) => GeometryHeightfieldSample, offered: GeometryHeightfieldRayOptions) => GeometryHeightfieldRayHit | null;
+
+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 interface RoomChannel {
+    readonly schema: Schema.Codec<unknown, unknown>;
+    readonly direction: 'both' | 'server' | 'client';
+    readonly reliable: boolean;
+}
+
+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>;
+
+/** 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. */
+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). */
+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>;
+}>;
+
+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;
+}>;
+
+/** Administrative intention only. World/version/owner/authority/baseline/patch
+ * are resolved by the actual Host/source, never accepted as client state. */
+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;
+}>;
+
+declare class RoomGone extends RoomGone_base {
+}
+
+declare const RoomGone_base: Schema.Class<RoomGone, Schema.TaggedStruct<"RoomGone", {
+    readonly roomId: Schema.String;
+}>, YieldableError>;
+
+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>;
+
+declare class SeatExpired extends SeatExpired_base {
+}
+
+declare const SeatExpired_base: Schema.Class<SeatExpired, Schema.TaggedStruct<"SeatExpired", {
+    readonly sessionId: Schema.String;
+}>, YieldableError>;
+
+/** Translation-only sweep of a box over heightfield terrain: the box moves on the raw grid from `from` to `to`
+ * (`position p` of `length` raw steps along the longest axis, other axes floored proportionally). Coarse steps of
+ * `stepRaw`; the first step that reaches under the surface is halved down to one raw step. Terrain entered and
+ * left within one coarse step can be missed: the step is the contract's resolution. `overlaps` answers one box
+ * (for example `overlapsGeometryHeightfieldBox` over the World surface); its own budget and refusals apply. */
+export declare const sweepGeometryHeightfieldBox: (offeredFrom: GeometryHeightfieldBoxRaw, offeredTo: GeometryHeightfieldBoxRaw, overlaps: (box: GeometryHeightfieldBoxRaw) => boolean, offeredOptions: GeometryHeightfieldSweepOptions) => GeometryHeightfieldSweepHit | null;
+
+export declare interface TiledGeometryImportOptions extends GeometryTileImportOptions {
+    /** Exact path through group names to one tile layer; duplicate names refuse. */
+    readonly layerPath: ReadonlyArray<string>;
+}
+
+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"];
+
+/** Real trusted manifest selects kind and digest. All bytes are owned and
+ * bounded under that actual kind's codec before the first native crypto await. */
+export declare const verifyGeometryArtifact: <K extends GeometryKind>(kind: K, offered: Uint8Array, expectedBlobSha256: string, limits?: GeometryArtifactLimits<K>) => Promise<GeometryArtifact<Extract<GeometryChunk, {
+    readonly kind: K;
+}>>>;
+
+export declare const verifyGeometryTileArtifact: (bytes: Uint8Array, expectedBlobSha256: string, limits?: Partial<GeometryTileLimits>) => Promise<GeometryTileArtifact>;
+
+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;
+}
+
+/** Pure whole-cell and clipped World/vertical-margin coverage. A chunk has one
+ * deterministic XY owner: its center, clamped inside the declared World map,
+ * resolved through the existing half-open World zone/cell topology. A cell may
+ * read a straddling chunk while an edit routes to its distinct owning cell. */
+export declare const worldCellGeometryCoverage: (offeredWorld: AnyWorldDescriptor, offeredRoot: GeometryPreparedScope, position: WorldPosition, offered?: GeometryCellCoverageOptions) => GeometryCellCoverage;
+
+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 World cell that owns a chunk: the cell under the chunk's center, clamped inside the
+ * declared World map (the same rule coverage uses to decide which cell may write a chunk). */
+export declare const worldGeometryChunkOwner: (offeredWorld: AnyWorldDescriptor, coordinate: {
+    readonly cx: number;
+    readonly cy: number;
+}) => WorldCell;
+
+export 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;
+    };
+}
+
+export 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;
+    };
+}
+
+/** Every chunk coordinate covering the declared World map, row by row — the inventory a complete static
+ * version needs so each cell's coverage (including margin chunks) loads. 3D kinds need an explicit vertical
+ * span in raw Q16 units. Refuses beyond `maxChunks` (default 4096) before expanding anything. */
+export declare const worldGeometryMapCoordinates: (offeredWorld: AnyWorldDescriptor, offered?: Pick<GeometryCellCoverageOptions, "vertical"> & {
+    readonly maxChunks?: number;
+}) => ReadonlyArray<GeometryPreparedCoordinate>;
+
+export 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';
+
+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 { }