@voltro/plugin-rooms 0.0.0-stage → 0.88.0

package/dist/geometryClient.d.ts

@@ -0,0 +1,1429 @@
+import { Duration } from 'effect';
+import { Schema } from 'effect';
+
+/** Configuration consumers never invoke a player callback. Its player type
+ * stays author-owned; this inventory type does not erase it into an input. */
+declare type AnyWorldDescriptor = WorldDescriptor<never>;
+
+export declare const captureGeometryAssetManifest: (offered: unknown, maxAssets?: number, maxBytes?: number) => GeometryAssetManifest;
+
+export declare const captureGeometryAssetReadGrant: (offered: unknown) => GeometryAssetReadGrant;
+
+export declare const captureGeometryAssetReadRequest: (offered: unknown) => GeometryAssetReadRequest;
+
+export declare const captureGeometryAssetReference: (offered: unknown) => GeometryAssetReference;
+
+export declare const captureGeometryAssetRoot: (offered: unknown) => GeometryAssetRoot;
+
+export declare const captureGeometryStreamManifest: (offered: unknown, maximumChunks?: number, maximumBytes?: number) => GeometryStreamManifest;
+
+export declare const decodeGeometryChunkHttpScope: (value: string | null) => GeometryPersistenceScope;
+
+/** Greatest admitted common divisor at or below the requested stride. Endpoint
+ * samples and exact raw extent remain unchanged; no averaging/float quantizer. */
+export declare const defaultGeometryHeightfieldLodStride: GeometryHeightfieldLodStride;
+
+export declare interface GeometryAdminClient {
+    reload(roomId: string, request: RoomGeometryReloadRequest, signal?: AbortSignal): Promise<void>;
+    rollback(roomId: string, request: RoomGeometryRollbackRequest, signal?: AbortSignal): Promise<void>;
+    observation(): GeometryAdminClientObservation;
+    /** Join accepted calls; unknown requests must resolve by exact explicit retry. */
+    close(): Promise<void>;
+}
+
+export declare interface GeometryAdminClientObservation {
+    readonly phase: 'open' | 'draining' | 'closed';
+    readonly pending: number;
+    readonly unconfirmed: number;
+    readonly retainedBytes: number;
+}
+
+export declare interface GeometryAdminClientOptions {
+    readonly caller: GeometryAdminRpcCaller;
+    readonly maxRetainedRequests?: number;
+    readonly maxRetainedBytes?: number;
+}
+
+export declare interface GeometryAdminRpcCaller {
+    /** Normal authenticated RPC caller; no credentials are accepted in this port. */
+    call(tag: GeometryAdminRpcTag, input: {
+        readonly roomId: string;
+        readonly request: RoomGeometryReloadRequest | RoomGeometryRollbackRequest;
+    }, options: {
+        readonly signal?: AbortSignal;
+    }): Promise<unknown>;
+}
+
+export declare type GeometryAdminRpcTag = 'rooms.geometry.reload' | 'rooms.geometry.rollback';
+
+declare interface GeometryArtifact<C extends GeometryChunk = GeometryChunk> {
+    readonly chunk: C;
+    readonly blobSha256: string;
+    /** Canonical declared content/layout, excluding actual address/version only. */
+    readonly contentSha256: string;
+    bytes(): Uint8Array;
+}
+
+declare type GeometryArtifactLimits<K extends GeometryKind> = K extends '2d-tiles' ? Partial<GeometryTileLimits> : K extends '2d-heightfield' ? Partial<GeometryHeightfieldLimits> : K extends '3d-shapes' ? Partial<GeometryShapesLimits> : Partial<GeometryVoxelLimits>;
+
+export declare interface GeometryAssetBundle {
+    readonly root: GeometryAssetRoot;
+    preload(signal: AbortSignal): Promise<void>;
+    at(key: string): GeometryVerifiedAsset;
+    observation(): {
+        readonly totalAssets: number;
+        readonly totalBytes: number;
+        readonly loadedAssets: number;
+        readonly loadedBytes: number;
+        readonly active: boolean;
+        readonly ready: boolean;
+        readonly closed: boolean;
+    };
+    /** Abort/join this bundle's actual accepted work only. Shared byte-cache and
+     * earlier detached aliases remain owned by their actual external lifetimes. */
+    close(): Promise<void>;
+}
+
+export declare interface GeometryAssetBundleOptions {
+    readonly source: Pick<GrantedGeometryAssetCache, 'load'>;
+    readonly maxAssets?: number;
+    readonly maxManifestBytes?: number;
+    readonly maxBytes?: number | undefined;
+    readonly maxConcurrent?: number | undefined;
+}
+
+export declare interface GeometryAssetGrantClient {
+    grant(request: GeometryAssetReadRequest, signal: AbortSignal): Promise<GeometryAssetReadGrant>;
+}
+
+export declare interface GeometryAssetManifest extends GeometryAssetRoot {
+    readonly assets: ReadonlyArray<GeometryAssetReference>;
+    readonly manifestSha256: string;
+}
+
+/** Canonical author/catalogue data only, never a grant or physical ownership
+ * proof. The actual SQL/CMS source owns publication/rights/erase/export. */
+export declare const geometryAssetManifest: (root: GeometryAssetRoot, offeredAssets: ReadonlyArray<GeometryAssetReference>, maxAssets?: number, maxBytes?: number) => GeometryAssetManifest;
+
+export declare interface GeometryAssetReadGrant {
+    readonly url: string;
+    readonly checksum: string;
+    readonly size: number;
+    readonly contentType: string;
+}
+
+export declare interface GeometryAssetReadRequest extends GeometryAssetRoot {
+    readonly key: string;
+}
+
+export declare interface GeometryAssetReference {
+    readonly key: string;
+    readonly fileId: string;
+    readonly bucket: string;
+    readonly checksum: string;
+    readonly size: number;
+    readonly contentType: string;
+}
+
+export declare interface GeometryAssetRoot {
+    readonly tenantId: string;
+    readonly worldId: string;
+    readonly layerSetId: string;
+    readonly version: string;
+}
+
+declare type GeometryChunk = GeometryTileChunk | GeometryHeightfieldChunk | GeometryShapesChunk | GeometryVoxelChunk;
+
+export declare const geometryChunkHttpHeaders: Readonly<{
+    scope: "x-voltro-geometry-scope";
+    revision: "x-voltro-geometry-revision";
+    contentSha256: "x-voltro-geometry-content-sha256";
+}>;
+
+/** Full scoped caller -> locator query only. Tenant/kind are resolved server-side;
+ * neither this query nor its coordinates grant read rights. */
+export declare const geometryChunkHttpQuery: (offered: GeometryPersistenceScope) => string;
+
+export declare interface GeometryChunkHttpResponse {
+    readonly status: 200;
+    readonly headers: Readonly<Record<string, string>>;
+    readonly body: Uint8Array;
+}
+
+/** Actual authorized SQL/source observation -> native binary HTTP response.
+ * Helper installs no route/authorization/cache policy or second chunk/Delta
+ * format. Caller must select trusted scope and read rights before invoking. */
+export declare const geometryChunkHttpResponse: (offered: GeometryPersistenceObservation, options?: {
+    readonly maxBytes?: number | undefined;
+}) => GeometryChunkHttpResponse;
+
+export declare interface GeometryClientChunkDownload {
+    readonly scope: GeometryPersistenceScope;
+    readonly revision: number;
+    readonly bytes: Uint8Array;
+    readonly blobSha256: string;
+    readonly contentSha256: string;
+}
+
+/** Actual authorized transport owns its request/stream close and must join it
+ * before settling, including abort. SHA/reference possession is not permission. */
+export declare interface GeometryClientChunkSource {
+    load(scope: GeometryPersistenceScope, signal: AbortSignal): Promise<GeometryClientChunkDownload>;
+}
+
+/** The same pure World field selection for streaming and native render data.
+ * Never substitutes a coarse representation for authoritative collision data. */
+export declare const geometryClientFieldsAtDistance: (offeredWorld: AnyWorldDescriptor, offeredDistance: number) => ReadonlyArray<string>;
+
+export declare interface GeometryClientInterest {
+    readonly scope: GeometryPreparedScope;
+    readonly center: GeometryPreparedCoordinate;
+    readonly radiusChunks: number;
+    readonly prefetchChunks: number;
+    readonly visitedCoordinates: number;
+    readonly omittedPrefetch: number;
+    readonly chunks: ReadonlyArray<GeometryClientInterestEntry>;
+}
+
+export declare interface GeometryClientInterestEntry {
+    readonly coordinate: GeometryPreparedCoordinate;
+    readonly distanceChunks: number;
+    readonly role: 'visible' | 'prefetch';
+    /** Declared render-field selection only. Native collision snapshots remain
+     * whole; this does not invent a coarse encoder/download/asset format. */
+    readonly fields: ReadonlyArray<string>;
+}
+
+export declare interface GeometryClientInterestOptions {
+    readonly maxChunks?: number | undefined;
+    readonly maxVisitedCoordinates?: number;
+    /** Actual render Transform velocity in raw units/second, never server authority. */
+    readonly velocity?: GeometryWorldPointRaw | undefined;
+}
+
+export declare interface GeometryClientStaticSource {
+    load(reference: GeometryStaticReference, signal: AbortSignal): Promise<GeometryArtifact>;
+}
+
+declare type GeometryCollisionDerive = (context: GeometryDerivationContext) => GeometryChunk;
+
+declare type GeometryCompaction = (context: GeometryCompactionContext) => GeometryPatch;
+
+/** Genuine immutable native artifacts only. Compaction preserves the current
+ * truth; it cannot authorize a different edit, owner, revision or SQL write. */
+declare interface GeometryCompactionContext {
+    readonly static: GeometryArtifact;
+    readonly current: GeometryArtifact;
+    readonly limits: GeometryPatchLimits;
+    readonly codecLimits: GeometryArtifactLimits<GeometryKind>;
+}
+
+declare interface GeometryCompactionStrategies {
+    readonly compaction: GeometryCompaction;
+}
+
+declare interface GeometryDeltaMigrationFrom {
+    readonly static: GeometryArtifact;
+    readonly current: GeometryArtifact;
+    readonly revision: number;
+}
+
+declare interface GeometryDeltaMigrationTo {
+    readonly static: GeometryArtifact;
+}
+
+/** Outside-Tick native data only. No query callback, provider, actor, Store or
+ * authority capability is accepted as a derivation result. */
+declare interface GeometryDerivationContext {
+    readonly chunk: GeometryChunk;
+    readonly codecLimits: GeometryArtifactLimits<GeometryKind>;
+}
+
+declare interface GeometryDerivationStrategies {
+    readonly collisionDerive: GeometryCollisionDerive;
+    readonly navDerive: GeometryNavDerive;
+}
+
+export declare interface GeometryDirtyChunkReference {
+    readonly scope: GeometryPersistenceScope;
+    readonly revision: number;
+    readonly blobSha256: string;
+    readonly contentSha256: string;
+}
+
+/** Trusted server snapshot. Never derive these rights, positions, budgets or
+ * catalogs from the intent body. App policy must recheck authority at commit. */
+declare interface GeometryEditAuthority {
+    readonly dynamicEnabled: boolean;
+    readonly ownsChunk: boolean;
+    readonly canBuild: boolean;
+    readonly cooldownReady: boolean;
+    readonly remainingOps: number;
+    readonly maxReachRaw: number;
+    readonly maxHeightUnits: number;
+    readonly position: {
+        readonly xRaw: number;
+        readonly yRaw: number;
+        readonly zRaw: number;
+    };
+    readonly materials: ReadonlyArray<GeometryTileMaterial>;
+    readonly shapes: ReadonlyArray<GeometryShapeTemplate>;
+}
+
+declare interface GeometryEditContext {
+    readonly chunk: GeometryChunk;
+    readonly intent: GeometryEditIntent;
+    readonly authority: GeometryEditAuthority;
+    readonly placementId: string;
+    readonly codecLimits?: GeometryArtifactLimits<GeometryKind> | undefined;
+}
+
+/** Player requests an action and its target, never solidity, shape dimensions,
+ * an authoritative player position, revision, owner, full chunk or Delta bytes. */
+declare type GeometryEditIntent = {
+    readonly op: 'setTile';
+    readonly x: number;
+    readonly y: number;
+    readonly material: string;
+} | {
+    readonly op: 'raiseHeight';
+    readonly x: number;
+    readonly y: number;
+    readonly units: number;
+} | {
+    readonly op: 'setVoxel';
+    readonly x: number;
+    readonly y: number;
+    readonly z: number;
+    readonly material: string;
+} | {
+    readonly op: 'placeShape';
+    readonly template: string;
+    readonly xRaw: number;
+    readonly yRaw: number;
+    readonly zRaw: number;
+} | {
+    readonly op: 'removeShape';
+    readonly id: string;
+};
+
+declare interface GeometryEditStrategies {
+    /** Pure policy slot. Current native Session/SQL ownership and codec integrity cannot be overridden by this slot. */
+    readonly opValidator: (context: GeometryEditContext) => void;
+    /** Pure rule slot; returned chunk is admitted under the original identity/layout/profile. */
+    readonly applyOp: (context: GeometryEditContext) => GeometryChunk;
+}
+
+declare type GeometryGenerator = (context: GeometryProceduralContext) => GeometryChunk;
+
+declare type GeometryHeightfieldChunk = (typeof GeometryHeightfieldChunkSchema)["Type"];
+
+declare const GeometryHeightfieldChunkSchema: Schema.Struct<{
+    readonly kind: Schema.Literal<"2d-heightfield">;
+    readonly formatVersion: Schema.Literal<1>;
+    readonly address: Schema.Struct<{
+        readonly worldId: Schema.String;
+        readonly layerSetId: Schema.String;
+        readonly cx: Schema.Int;
+        readonly cy: Schema.Int;
+    }>;
+    readonly version: Schema.String;
+    readonly width: Schema.Int;
+    readonly height: Schema.Int;
+    readonly sampleSpacingRaw: Schema.Int;
+    readonly baseHeightRaw: Schema.Int;
+    readonly heightQuantumRaw: Schema.Int;
+    readonly heights: Schema.$Array<Schema.Int>;
+}>;
+
+declare interface GeometryHeightfieldLimits {
+    readonly maxSide: number;
+    readonly maxSamples: number;
+    readonly maxBytes: number;
+}
+
+export declare interface GeometryHeightfieldLodOptions {
+    readonly maxStride?: number;
+    readonly maxSamples?: number | undefined;
+    readonly codecLimits?: Partial<GeometryHeightfieldLimits> | undefined;
+    readonly strategies?: {
+        readonly sampleStride?: GeometryHeightfieldLodStride;
+    } | undefined;
+}
+
+export declare type GeometryHeightfieldLodStride = (chunk: GeometryHeightfieldChunk, maxStride: number) => number;
+
+declare interface GeometryHeightfieldView {
+    readonly chunk: GeometryHeightfieldChunk;
+    heightAtSample(x: number, y: number): number;
+    heightAtRaw(xRaw: number, yRaw: number): number;
+}
+
+export declare interface GeometryHttpChunkSourceOptions {
+    /** Actual registered/authenticated endpoint or granted URL. No locator,
+     * credentials, scope grant or static version is inferred from a digest. */
+    readonly urlFor: (scope: GeometryPersistenceScope) => string;
+    readonly fetch?: typeof globalThis.fetch;
+    readonly maxResponseBytes?: number;
+    readonly maxReadChunks?: number;
+}
+
+export declare interface GeometryHttpStaticSourceOptions {
+    /** Actual storage/CDN read grant; scope/digest never creates a locator. */
+    readonly urlFor: (reference: GeometryStaticReference) => string;
+    readonly fetch?: typeof globalThis.fetch;
+    readonly maxResponseBytes?: number;
+    readonly maxReadChunks?: number;
+    readonly codecLimits?: {
+        readonly [K in GeometryKind]?: GeometryArtifactLimits<K>;
+    } | undefined;
+}
+
+declare type GeometryKind = GeometryChunk['kind'];
+
+export declare type GeometryManifestIdentity = Pick<GeometryPreparedScope, 'tenantId' | 'kind' | 'worldId' | 'layerSetId'>;
+
+/** Pure native data rule only; no SQL, actor, journal, permission or Subject. */
+declare type GeometryMigrateDelta = (from: GeometryDeltaMigrationFrom, to: GeometryDeltaMigrationTo) => GeometryChunk | null;
+
+declare type GeometryNavDerive = (context: GeometryDerivationContext) => GeometryTileChunk | null;
+
+declare interface GeometryPatch {
+    readonly metadata: GeometryPatchMetadata;
+    bytes(): Uint8Array;
+}
+
+declare interface GeometryPatchLimits {
+    readonly maxBytes: number;
+    readonly maxMetadataBytes: number;
+}
+
+declare type GeometryPatchMetadata = (typeof GeometryPatchMetadataSchema)["Type"];
+
+declare const GeometryPatchMetadataSchema: Schema.Struct<{
+    readonly kind: Schema.Literals<readonly ["2d-tiles", "2d-heightfield", "3d-shapes", "3d-voxel"]>;
+    readonly formatVersion: Schema.Literal<1>;
+    readonly worldId: Schema.String;
+    readonly layerSetId: Schema.String;
+    readonly cx: Schema.Int;
+    readonly cy: Schema.Int;
+    readonly cz: Schema.optional<Schema.Int>;
+    readonly version: Schema.String;
+    readonly baseRevision: Schema.Int;
+    readonly revision: Schema.Int;
+    readonly baseBlobSha256: Schema.String;
+    readonly blobSha256: Schema.String;
+    readonly baseContentSha256: Schema.String;
+    readonly contentSha256: Schema.String;
+    readonly changed: Schema.Boolean;
+    readonly stateSchemaHash: Schema.Int;
+}>;
+
+declare interface GeometryPersistenceObservation {
+    readonly scope: GeometryPersistenceScope;
+    readonly revision: number;
+    readonly artifact: GeometryArtifact;
+}
+
+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;
+}
+
+declare interface GeometryPersistenceSubject {
+    readonly id: string;
+    readonly kind: 'user' | 'guest';
+}
+
+declare interface GeometryPointRaw3D {
+    readonly xRaw: number;
+    readonly yRaw: number;
+    readonly zRaw: number;
+}
+
+declare interface GeometryPreparedCoordinate {
+    readonly cx: number;
+    readonly cy: number;
+    readonly cz?: number | undefined;
+}
+
+declare type GeometryPreparedEntry = PreparedCommon & GeometryPreparedView & {
+    /** Independently prepared native collision data. Original view/artifact remains the edit/rebuild baseline. */
+    readonly collision: GeometryPreparedView;
+    readonly navigation: GeometryTileView | null;
+};
+
+declare interface GeometryPreparedInventory {
+    readonly scope: GeometryPreparedScope;
+    readonly entries: ReadonlyArray<GeometryPreparedEntry>;
+    readonly accountedBytes: number;
+    /** CPU-only lookup; absence is explicit, never an empty collision chunk. */
+    at(coordinate: GeometryPreparedCoordinate): GeometryPreparedEntry;
+    contains(coordinate: GeometryPreparedCoordinate): boolean;
+}
+
+declare interface GeometryPreparedScope {
+    readonly tenantId: string;
+    readonly kind: GeometryKind;
+    readonly worldId: string;
+    readonly layerSetId: string;
+    readonly version: string;
+}
+
+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;
+});
+
+declare interface GeometryProceduralContext {
+    readonly seed: number;
+    readonly kind: GeometryKind;
+    readonly address: GeometryChunk['address'];
+    readonly version: string;
+}
+
+export declare interface GeometryReadGrantClient {
+    grant(reference: GeometryStaticReference, signal: AbortSignal): Promise<string>;
+}
+
+export declare interface GeometryRenderLod {
+    readonly fields: ReadonlyArray<string>;
+    readonly sampleStride: number;
+    readonly sourceBlobSha256: string;
+    readonly sourceContentSha256: string;
+    readonly artifact: GeometryArtifact;
+    /** Present when both full heights and heightsCoarse are selected. */
+    readonly coarseArtifact?: GeometryArtifact;
+}
+
+export declare interface GeometryRenderLodCache {
+    prepare(coordinate: GeometryPreparedCoordinate, distanceChunks: number): Promise<GeometryRenderLod>;
+    at(coordinate: GeometryPreparedCoordinate, distanceChunks: number): GeometryRenderLod;
+    observation(): {
+        readonly entries: number;
+        readonly encodedBytes: number;
+        readonly jobs: number;
+        readonly closed: boolean;
+        readonly withdrawn: boolean;
+    };
+    /** Clears owned references and joins all accepted preparation/hash work. It
+     * never closes the borrowed native cache/Session or erases earlier aliases. */
+    close(): Promise<void>;
+}
+
+export declare interface GeometryRenderLodCacheOptions {
+    readonly maxEntries?: number;
+    readonly maxEncodedBytes?: number;
+    readonly maxConcurrent?: number | undefined;
+    readonly lod?: GeometryHeightfieldLodOptions;
+    readonly strategies?: {
+        readonly prepare?: GeometryRenderLodPreparer;
+    } | undefined;
+}
+
+export declare type GeometryRenderLodPreparer = (world: AnyWorldDescriptor, artifact: GeometryArtifact, distanceChunks: number, options: GeometryHeightfieldLodOptions) => Promise<GeometryRenderLod>;
+
+export declare const geometryRpcAssetGrants: (offered: RoomRpcCaller) => GeometryAssetGrantClient;
+
+export declare const geometryRpcReadGrants: (offered: RoomRpcCaller) => GeometryReadGrantClient;
+
+declare type GeometryShape = (typeof GeometryShapeSchema)["Type"];
+
+declare const GeometryShapeSchema: Schema.Union<readonly [Schema.Struct<{
+    readonly halfXRaw: Schema.Int;
+    readonly halfYRaw: Schema.Int;
+    readonly halfZRaw: Schema.Int;
+    readonly id: Schema.String;
+    readonly xRaw: Schema.Int;
+    readonly yRaw: Schema.Int;
+    readonly zRaw: Schema.Int;
+    readonly kind: Schema.Literal<"aabb">;
+}>, Schema.Struct<{
+    readonly radiusRaw: Schema.Int;
+    readonly id: Schema.String;
+    readonly xRaw: Schema.Int;
+    readonly yRaw: Schema.Int;
+    readonly zRaw: Schema.Int;
+    readonly kind: Schema.Literal<"sphere">;
+}>]>;
+
+declare type GeometryShapesChunk = (typeof GeometryShapesChunkSchema)["Type"];
+
+declare const GeometryShapesChunkSchema: Schema.Struct<{
+    readonly kind: Schema.Literal<"3d-shapes">;
+    readonly formatVersion: Schema.Literal<1>;
+    readonly address: Schema.Struct<{
+        readonly worldId: Schema.String;
+        readonly layerSetId: Schema.String;
+        readonly cx: Schema.Int;
+        readonly cy: Schema.Int;
+        readonly cz: Schema.Int;
+    }>;
+    readonly version: Schema.String;
+    readonly extentXRaw: Schema.Int;
+    readonly extentYRaw: Schema.Int;
+    readonly extentZRaw: Schema.Int;
+    readonly shapes: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+        readonly halfXRaw: Schema.Int;
+        readonly halfYRaw: Schema.Int;
+        readonly halfZRaw: Schema.Int;
+        readonly id: Schema.String;
+        readonly xRaw: Schema.Int;
+        readonly yRaw: Schema.Int;
+        readonly zRaw: Schema.Int;
+        readonly kind: Schema.Literal<"aabb">;
+    }>, Schema.Struct<{
+        readonly radiusRaw: Schema.Int;
+        readonly id: Schema.String;
+        readonly xRaw: Schema.Int;
+        readonly yRaw: Schema.Int;
+        readonly zRaw: Schema.Int;
+        readonly kind: Schema.Literal<"sphere">;
+    }>]>>;
+}>;
+
+declare interface GeometryShapesLimits {
+    readonly maxShapes: number;
+    readonly maxBytes: number;
+}
+
+declare interface GeometryShapesView {
+    readonly chunk: GeometryShapesChunk;
+    containingRaw(point: GeometryPointRaw3D, maximumShapes?: number): ReadonlyArray<GeometryShape>;
+    /** Closed LOCAL segment and native volumes. Canonical ID order, not distance
+     * order; no first-hit fraction or cross-chunk ownership is implied. */
+    intersectingSegmentRaw(from: GeometryPointRaw3D, to: GeometryPointRaw3D, maximumShapes?: number): ReadonlyArray<GeometryShape>;
+}
+
+declare type GeometryShapeTemplate = {
+    readonly key: string;
+    readonly kind: 'aabb';
+    readonly halfXRaw: number;
+    readonly halfYRaw: number;
+    readonly halfZRaw: number;
+} | {
+    readonly key: string;
+    readonly kind: 'sphere';
+    readonly radiusRaw: number;
+};
+
+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;
+};
+
+declare interface GeometryStaticReference extends GeometryPersistenceScope {
+    readonly blobSha256: string;
+    readonly contentSha256: string;
+}
+
+/** Authorized layer-set projection of an immutable version plus independently
+ * observed SQL dirty revisions, not one global actor frame or a read grant. */
+export declare interface GeometryStreamManifest {
+    readonly scope: GeometryPreparedScope;
+    readonly manifestSha256: string;
+    readonly chunks: ReadonlyArray<GeometryStaticReference>;
+    readonly dirtyChunks: ReadonlyArray<GeometryDirtyChunkReference>;
+}
+
+declare interface GeometryTileCellBounds {
+    readonly minXRaw: number;
+    readonly minYRaw: number;
+    readonly maxXRaw: number;
+    readonly maxYRaw: number;
+}
+
+declare type GeometryTileChunk = (typeof GeometryTileChunkSchema)["Type"];
+
+declare const GeometryTileChunkSchema: Schema.Struct<{
+    readonly kind: Schema.Literal<"2d-tiles">;
+    readonly formatVersion: Schema.Literal<1>;
+    readonly address: Schema.Struct<{
+        readonly worldId: Schema.String;
+        readonly layerSetId: Schema.String;
+        readonly cx: Schema.Int;
+        readonly cy: Schema.Int;
+    }>;
+    readonly version: Schema.String;
+    readonly width: Schema.Int;
+    readonly height: Schema.Int;
+    readonly tileSizeRaw: Schema.Int;
+    readonly palette: Schema.$Array<Schema.Struct<{
+        readonly key: Schema.String;
+        readonly solid: Schema.Boolean;
+    }>>;
+    readonly runs: Schema.$Array<Schema.Struct<{
+        readonly paletteIndex: Schema.Int;
+        readonly length: Schema.Int;
+    }>>;
+}>;
+
+declare interface GeometryTileLimits {
+    readonly maxSide: number;
+    readonly maxCells: number;
+    readonly maxPalette: number;
+    readonly maxRuns: number;
+    readonly maxBytes: number;
+}
+
+declare type GeometryTileMaterial = (typeof GeometryTileMaterialSchema)["Type"];
+
+declare const GeometryTileMaterialSchema: Schema.Struct<{
+    readonly key: Schema.String;
+    readonly solid: Schema.Boolean;
+}>;
+
+declare interface GeometryTileView {
+    readonly chunk: GeometryTileChunk;
+    /** Local integer cell queries. Outside cells refuse; no missing-neighbor air. */
+    materialAt(x: number, y: number): GeometryTileMaterial;
+    solidAt(x: number, y: number): boolean;
+    materialAtRaw(xRaw: number, yRaw: number): GeometryTileMaterial;
+    cellBounds(x: number, y: number): GeometryTileCellBounds;
+    /** Detached row-major little-bit occupancy, never the retained mutable grid. */
+    occupancy(): Uint8Array;
+}
+
+/** Actual client render sample only. No authority, server state message or 3D
+ * velocity invention. Raw Q16.16 conversion refuses overflow instead of wrapping. */
+export declare const geometryTransformInterest2D: (offered: Transform2D) => {
+    readonly focus: GeometryWorldPointRaw;
+    readonly velocity: GeometryWorldPointRaw;
+};
+
+export declare interface GeometryVerifiedAsset {
+    readonly root: GeometryAssetRoot;
+    readonly key: string;
+    readonly checksum: string;
+    readonly size: number;
+    readonly contentType: string;
+    /** Detached owned bytes; no URL/token/permission retained. */
+    bytes(): Uint8Array;
+}
+
+declare interface GeometryVersionMigrationStrategies {
+    readonly migrateDelta?: GeometryMigrateDelta;
+}
+
+declare type GeometryVoxelChunk = (typeof GeometryVoxelChunkSchema)["Type"];
+
+declare const GeometryVoxelChunkSchema: Schema.Struct<{
+    readonly kind: Schema.Literal<"3d-voxel">;
+    readonly formatVersion: Schema.Literal<1>;
+    readonly address: Schema.Struct<{
+        readonly worldId: Schema.String;
+        readonly layerSetId: Schema.String;
+        readonly cx: Schema.Int;
+        readonly cy: Schema.Int;
+        readonly cz: Schema.Int;
+    }>;
+    readonly version: Schema.String;
+    readonly side: Schema.Int;
+    readonly voxelSizeRaw: Schema.Int;
+    readonly palette: Schema.$Array<Schema.Struct<{
+        readonly key: Schema.String;
+        readonly solid: Schema.Boolean;
+    }>>;
+    readonly sections: Schema.$Array<Schema.Struct<{
+        readonly sx: Schema.Int;
+        readonly sy: Schema.Int;
+        readonly sz: Schema.Int;
+        readonly runs: Schema.$Array<Schema.Struct<{
+            readonly paletteIndex: Schema.Int;
+            readonly length: Schema.Int;
+        }>>;
+    }>>;
+}>;
+
+declare interface GeometryVoxelLimits {
+    readonly maxSide: number;
+    readonly maxVoxels: number;
+    readonly maxPalette: number;
+    readonly maxSections: number;
+    readonly maxRunsPerSection: number;
+    readonly maxBytes: number;
+}
+
+declare interface GeometryVoxelView {
+    readonly chunk: GeometryVoxelChunk;
+    materialAt(x: number, y: number, z: number): GeometryTileMaterial;
+    solidAt(x: number, y: number, z: number): boolean;
+    materialAtRaw(xRaw: number, yRaw: number, zRaw: number): GeometryTileMaterial;
+    occupancy(): Uint8Array;
+}
+
+declare interface GeometryWorldPointRaw {
+    readonly xRaw: number;
+    readonly yRaw: number;
+    readonly zRaw?: number;
+}
+
+export declare interface GrantedGeometryAssetCache {
+    load(request: GeometryAssetReadRequest, signal: AbortSignal): Promise<GeometryVerifiedAsset>;
+    observation(): {
+        readonly cached: number;
+        readonly cachedBytes: number;
+        readonly active: number;
+        readonly closed: boolean;
+    };
+    close(): Promise<void>;
+}
+
+export declare interface GrantedGeometryAssetCacheOptions {
+    readonly grants: GeometryAssetGrantClient;
+    readonly fetch?: typeof globalThis.fetch;
+    readonly maxCachedAssets?: number;
+    readonly maxCachedBytes?: number;
+    readonly maxInFlight?: number;
+    readonly maxResponseBytes?: number;
+    readonly maxReadChunks?: number;
+}
+
+export declare interface GrantedGeometryHttpStaticCache {
+    /** Exact minimal source capability for manifest/native recovery composition. */
+    readonly source: GeometryClientStaticSource;
+    observation(): {
+        readonly cached: number;
+        readonly accountedBytes: number;
+        readonly active: number;
+        readonly closed: boolean;
+    };
+    close(): Promise<void>;
+}
+
+export declare interface GrantedGeometryHttpStaticCacheOptions extends GrantedGeometryHttpStaticSourceOptions {
+    readonly maxCachedArtifacts?: number;
+    readonly maxCachedBytes?: number;
+    readonly maxInFlight?: number;
+}
+
+export declare interface GrantedGeometryHttpStaticSourceOptions extends Omit<GeometryHttpStaticSourceOptions, 'urlFor'> {
+    readonly grants: GeometryReadGrantClient;
+}
+
+/** One captured authenticated caller lifetime. App owns it across component
+ * mounts and auth scope changes. No localStorage, tokens, queue, timer, automatic
+ * retry or invented receipts. Caller owns actual auth transport and cancellation. */
+export declare const makeGeometryAdminClient: (offered: GeometryAdminClientOptions) => GeometryAdminClient;
+
+/** Actual author/published catalogue and real source Port. Complete bounded
+ * preflight before work, current source grants on every preload/retry, genuine
+ * size/MIME/checksum+actual byte/hash checks; no fake progress or default assets. */
+export declare const makeGeometryAssetBundle: (offeredManifest: GeometryAssetManifest, offered: GeometryAssetBundleOptions) => GeometryAssetBundle;
+
+/** Native Fetch/ReadableStream transport only; same full snapshot bytes, never
+ * another Delta format. Cache still performs native scope/content/hash/extent
+ * verification. No auto route, credentials minting, retry, CDN or SQL assertion. */
+export declare const makeGeometryHttpChunkSource: (offered: GeometryHttpChunkSourceOptions) => GeometryClientChunkSource;
+
+/** Native immutable artifact over actual Fetch. No custom CDN headers/ETag format
+ * assumed; trusted reference's actual blob+content SHA/codec/scope are verified. */
+export declare const makeGeometryHttpStaticSource: (offered: GeometryHttpStaticSourceOptions) => GeometryClientStaticSource;
+
+/** Owned render-only bounded LRU over the genuine borrowed native cache. Keys
+ * include actual source blob and World fields, not permission/URL/time. Reads
+ * always verify the current native artifact again; no stale render fallback. */
+export declare const makeGeometryRenderLodCache: (offeredCache: RoomGeometryChunkCache, offeredWorld: AnyWorldDescriptor, offeredOptions?: GeometryRenderLodCacheOptions) => GeometryRenderLodCache;
+
+/** Fresh grant for every request/hit, same owned bounded native HTTP reader,
+ * exact bytes+MIME+SHA. Own byte cache/read jobs; no CDN origin guessing,
+ * persistent URL/token/permission, automatic retry, decoder or worker. */
+export declare const makeGrantedGeometryAssetCache: (offered: GrantedGeometryAssetCacheOptions) => GrantedGeometryAssetCache;
+
+/** Fresh grant for every call, including local unchanged-version reuse. One
+ * canonical implementation for owned cache and the unretained source facade. */
+export declare const makeGrantedGeometryHttpStaticCache: (offered: GrantedGeometryHttpStaticCacheOptions) => GrantedGeometryHttpStaticCache;
+
+/** Actual grant RPC/Port ->same bounded native static HTTP source. No cached
+ * permission/token/TTL/locator or actual request cleanup inference. */
+export declare const makeGrantedGeometryHttpStaticSource: (offered: GrantedGeometryHttpStaticSourceOptions) => GeometryClientStaticSource;
+
+export declare const makeManifestGeometryChunkSource: (offered: ManifestGeometryChunkSourceOptions) => GeometryClientChunkSource;
+
+/** Actual joined connection ->same native cache. Root/version/rights/source and
+ * initial interest remain explicit actual capabilities, never guessed. */
+export declare const makeRoomConnectionGeometryCache: (actualConnection: unknown, world: AnyWorldDescriptor, root: GeometryPreparedScope, source: GeometryClientChunkSource, options?: RoomGeometryChunkCacheOptions) => RoomGeometryChunkCache;
+
+export declare const makeRoomConnectionGeometryManifestClient: (actualConnection: unknown, identity: GeometryManifestIdentity, options?: RoomGeometryManifestClientOptions) => RoomGeometryManifestClient;
+
+/** Actual joined connection ->same native snapshot recovery source: an edited chunk's current state over the
+ * Room's request/snapshot channels. Bound to the connection's current Session, like the cache. */
+export declare const makeRoomConnectionGeometrySnapshotSource: (actualConnection: unknown, root: GeometryPreparedScope, options: RoomGeometrySnapshotSourceOptions) => RoomGeometrySnapshotSource;
+
+export declare const makeRoomConnectionGeometryVersionClient: (actualConnection: unknown, world: AnyWorldDescriptor, identity: GeometryManifestIdentity, options: RoomGeometryVersionClientOptions) => RoomGeometryVersionClient;
+
+/** Browser-safe explicit native cache; no SQL, silent source fallback, timer,
+ * automatic retry, CDN locator guess or server-authority assertion. */
+export declare const makeRoomGeometryChunkCache: (actualSession: unknown, offeredWorld: AnyWorldDescriptor, offeredRoot: GeometryPreparedScope, offeredSource: GeometryClientChunkSource, offered?: RoomGeometryChunkCacheOptions) => RoomGeometryChunkCache;
+
+/** Real native joined reliable-channel subscription -> bounded actual GPD
+ * reassembly -> native hashes/queries -> owned CPU pointer. Server-reported SQL
+ * receipt is not a client SQL check; static/version/recovery custody is external. */
+export declare const makeRoomGeometryClient: (actualSession: unknown, offeredInventory: GeometryPreparedInventory, offered?: RoomGeometryClientOptions) => RoomGeometryClient;
+
+/** Actual compiled reliable native metadata only; no inferred locator/read grant,
+ * blob download, static format, SQL attestation or autonomous pump. */
+export declare const makeRoomGeometryManifestClient: (actualSession: unknown, offeredIdentity: GeometryManifestIdentity, offered?: RoomGeometryManifestClientOptions) => RoomGeometryManifestClient;
+
+/** Intention-only actual reliable request ->existing native net snapshot ->
+ * verified static/GPD/current revision. No private HTTP/SQL/transport or auto retry. */
+export declare const makeRoomGeometrySnapshotSource: (actualSession: unknown, offeredRoot: GeometryPreparedScope, offered: RoomGeometrySnapshotSourceOptions) => RoomGeometrySnapshotSource;
+
+/** Browser-safe native Session owner. Owns metadata, per-version request source
+ * and chunk cache; borrows Session and static grant/HTTP lifetime. A published
+ * version is server metadata, never client SQL/lease/authority attestation. */
+export declare const makeRoomGeometryVersionClient: (actualSession: unknown, offeredWorld: AnyWorldDescriptor, offeredIdentity: GeometryManifestIdentity, offered: RoomGeometryVersionClientOptions) => RoomGeometryVersionClient;
+
+export declare interface ManifestGeometryChunkSourceOptions {
+    /** Actual admitted native manifest client's current immutable metadata. */
+    readonly manifest: () => GeometryStreamManifest;
+    readonly staticSource: GeometryClientStaticSource;
+    /** Actual current dynamic recovery transport, e.g. `makeRoomConnectionGeometrySnapshotSource` (only its `load`
+     * is read); absent refuses dirty changes. */
+    readonly recovery?: GeometryClientChunkSource;
+    readonly maxManifestChunks?: number | undefined;
+    readonly maxManifestBytes?: number;
+    readonly maxChunkBytes?: number;
+    readonly codecLimits?: {
+        readonly [K in GeometryKind]?: GeometryArtifactLimits<K>;
+    } | undefined;
+}
+
+/** Pure client rendering plan, never a server player position/permission or
+ * background download loop. All visible chunks retained, nearest prefetch
+ * clipped to actual cache budget; enumeration is admitted before allocation. */
+export declare const planGeometryClientInterest: (offeredWorld: AnyWorldDescriptor, offeredRoot: GeometryPreparedScope, offeredFocus: GeometryWorldPointRaw, offered?: GeometryClientInterestOptions) => GeometryClientInterest;
+
+/** Native connection +actual complete source batch with owned abort cleanup.
+ * App selects full root/current read rights and coordinates; no version guess. */
+export declare const prefetchRoomConnectionGeometryCache: (actualConnection: unknown, world: AnyWorldDescriptor, root: GeometryPreparedScope, source: GeometryClientChunkSource, coordinates: ReadonlyArray<GeometryPreparedCoordinate>, signal: AbortSignal, options?: RoomGeometryChunkCacheOptions) => Promise<RoomGeometryChunkCache>;
+
+declare interface PreparedCommon {
+    readonly scope: GeometryPersistenceScope;
+    readonly revision: number;
+    readonly blobSha256: string;
+    readonly contentSha256: string;
+    readonly accountedBytes: number;
+}
+
+/** Actual native heightfield codec and hashes, for render data only. Original
+ * artifact is immutable and unchanged. It is not a full-resolution delta base,
+ * collision substitute, new persistence format or CDN authority reference. */
+export declare const prepareGeometryHeightfieldLod: (offeredArtifact: GeometryArtifact, offered?: GeometryHeightfieldLodOptions) => Promise<GeometryRenderLod>;
+
+/** One World field rule for all kinds. Only the declared heightsCoarse field
+ * invokes native height projection; full fields retain their genuine artifact.
+ * This local preparation does not claim reduced network downloads or assets. */
+export declare const prepareGeometryRenderLod: (offeredWorld: AnyWorldDescriptor, offeredArtifact: GeometryArtifact, offeredDistance: number, options?: GeometryHeightfieldLodOptions) => Promise<GeometryRenderLod>;
+
+/** Re-encode retained genuine static content under an actual new reference.
+ * Caller must separately obtain current read rights; a hash is not permission. */
+export declare const reuseGeometryStaticArtifact: (offeredArtifact: unknown, offeredReference: GeometryStaticReference, codecLimits?: GeometryArtifactLimits<GeometryKind>) => Promise<GeometryArtifact | null>;
+
+export declare interface RoomGeometryChunkCache {
+    /** Last downloaded native query snapshot, never implied empty terrain. */
+    at(coordinate: GeometryPreparedCoordinate): GeometryPreparedEntry;
+    contains(coordinate: GeometryPreparedCoordinate): boolean;
+    /** Full requested set commits to bounded LRU only after all loads/hash/views
+     * complete. Failed batches preserve earlier same-admission snapshots. */
+    request(coordinates: ReadonlyArray<GeometryPreparedCoordinate>): Promise<void>;
+    /** Explicit render-frame work: native Deltas/recovery, visible-first load,
+     * directional prefetch and old-cache hysteresis. Caller awaits each frame. */
+    stream(focus: GeometryWorldPointRaw, options?: GeometryClientInterestOptions): Promise<GeometryClientInterest>;
+    /** Explicit current source reconciliation, including already cached chunks. */
+    /** Explicit serial native Delta application; gaps require actual source recovery. */
+    pump(): Promise<{
+        readonly applied: number;
+        readonly duplicates: number;
+        readonly obsolete: number;
+        readonly recovery: ReadonlyArray<GeometryPreparedCoordinate>;
+    }>;
+    refresh(coordinates: ReadonlyArray<GeometryPreparedCoordinate>): Promise<void>;
+    close(): Promise<void>;
+    observation(): RoomGeometryChunkCacheObservation;
+}
+
+export declare interface RoomGeometryChunkCacheObservation {
+    readonly cached: number;
+    readonly accountedBytes: number;
+    readonly staged: number;
+    readonly stagedBytes: number;
+    readonly active: boolean;
+    readonly withdrawn: boolean;
+    readonly stale: number;
+    readonly queuedDeltas: number;
+    readonly queuedDeltaBytes: number;
+    readonly receiving: number;
+    readonly receivingBytes: number;
+}
+
+export declare interface RoomGeometryChunkCacheOptions {
+    readonly channel?: string | undefined;
+    readonly maxCachedChunks?: number;
+    readonly maxConcurrent?: number | undefined;
+    readonly maxCacheBytes?: number;
+    readonly maxStagedBytes?: number;
+    readonly maxChunkBytes?: number;
+    readonly maxPendingDeltas?: number;
+    readonly maxQueuedDeltaBytes?: number;
+    readonly codecLimits?: {
+        readonly [K in GeometryKind]?: GeometryArtifactLimits<K>;
+    } | undefined;
+}
+
+export declare interface RoomGeometryClient {
+    at(coordinate: GeometryPreparedCoordinate): GeometryPreparedEntry;
+    contains(coordinate: GeometryPreparedCoordinate): boolean;
+    /** Explicit serial native hash/application/query preparation outside rendering or Tick. No autonomous worker. */
+    pump(): Promise<{
+        readonly applied: number;
+        readonly duplicates: number;
+        readonly unchanged: number;
+    }>;
+    /** Detach/reset owned data. The actual Room Session/transport lifetime is borrowed. */
+    close(): Promise<void>;
+    observation(): RoomGeometryClientObservation;
+}
+
+export declare interface RoomGeometryClientObservation {
+    readonly queued: number;
+    readonly queuedBytes: number;
+    readonly receiving: number;
+    readonly receivingBytes: number;
+    readonly history: number;
+    readonly historyBytes: number;
+    readonly active: boolean;
+    readonly withdrawn: boolean;
+    readonly failed: boolean;
+    readonly generation: number;
+}
+
+export declare interface RoomGeometryClientOptions {
+    readonly channel?: string | undefined;
+    readonly maxQueued?: number;
+    readonly maxQueuedBytes?: number;
+    readonly maxPatchBytes?: number | undefined;
+    readonly maxHistory?: number;
+    readonly maxHistoryBytes?: number;
+}
+
+export declare interface RoomGeometryManifestClient {
+    current(): GeometryStreamManifest;
+    pump(): Promise<{
+        readonly accepted: number;
+    }>;
+    close(): Promise<void>;
+    observation(): {
+        readonly queued: number;
+        readonly queuedBytes: number;
+        readonly receiving: number;
+        readonly receivingBytes: number;
+        readonly ready: boolean;
+        readonly active: boolean;
+        readonly withdrawn: boolean;
+    };
+}
+
+export declare interface RoomGeometryManifestClientOptions {
+    readonly channel?: string | undefined;
+    readonly maxManifestChunks?: number | undefined;
+    readonly maxManifestBytes?: number;
+    readonly maxPending?: number | undefined;
+    readonly maxPendingBytes?: number | undefined;
+    readonly maxQueued?: number;
+    readonly maxQueuedBytes?: number;
+}
+
+declare interface RoomGeometryReloadRequest {
+    readonly version: string;
+    readonly requestId: 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 interface RoomGeometrySnapshotSource extends GeometryClientChunkSource {
+    close(): Promise<void>;
+    observation(): {
+        readonly pending: number;
+        readonly jobs: number;
+        readonly receiving: number;
+        readonly receivingBytes: number;
+        readonly withdrawn: boolean;
+    };
+}
+
+export declare interface RoomGeometrySnapshotSourceOptions {
+    readonly manifest: () => GeometryStreamManifest;
+    readonly staticSource: GeometryClientStaticSource;
+    readonly requestChannel?: string;
+    readonly responseChannel?: string;
+    readonly requestId?: (() => string) | undefined;
+    readonly maxPending?: number | undefined;
+    readonly maxPatchBytes?: number | undefined;
+    readonly maxPendingBytes?: number | undefined;
+    readonly maxWaitMs?: number;
+    readonly maxManifestChunks?: number | undefined;
+    readonly maxManifestBytes?: number;
+    readonly codecLimits?: {
+        readonly [K in GeometryKind]?: GeometryArtifactLimits<K>;
+    } | undefined;
+}
+
+export declare interface RoomGeometryVersionClient {
+    at(coordinate: GeometryPreparedCoordinate): GeometryPreparedEntry;
+    contains(coordinate: GeometryPreparedCoordinate): boolean;
+    /** Owned local render preparation over the selected verified version. */
+    render(coordinate: GeometryPreparedCoordinate, distanceChunks: number): Promise<GeometryRenderLod>;
+    /** One explicit awaited render frame: manifest pump, version handoff, then
+     * existing visible-first native stream. No timer or player-state upload. */
+    stream(focus: GeometryWorldPointRaw, options?: GeometryClientInterestOptions): Promise<GeometryClientInterest>;
+    observation(): {
+        readonly scope: GeometryPreparedScope | null;
+        readonly ready: boolean;
+        readonly active: boolean;
+        readonly withdrawn: boolean;
+        readonly retiring: number;
+        readonly renderEntries: number;
+        readonly renderEncodedBytes: number;
+        readonly renderJobs: number;
+    };
+    close(): Promise<void>;
+}
+
+export declare interface RoomGeometryVersionClientOptions {
+    /** Borrowed current authorized immutable static reader. Its lifetime remains
+     * external; compose the fresh-granted static cache for unchanged version reuse. */
+    readonly staticSource: GeometryClientStaticSource;
+    readonly manifest?: RoomGeometryManifestClientOptions;
+    readonly snapshot?: Omit<RoomGeometrySnapshotSourceOptions, 'manifest' | 'staticSource'>;
+    readonly cache?: RoomGeometryChunkCacheOptions;
+    readonly render?: GeometryRenderLodCacheOptions;
+}
+
+declare interface RoomRpcCaller {
+    call(tag: string, input: unknown, options: {
+        readonly signal: AbortSignal;
+    }): Promise<unknown>;
+    /** Normal framework live-query callback boundary. No polling adapter. */
+    readonly subscribe?: (tag: string, input: unknown, handlers: {
+        readonly onValue: (value: unknown) => void;
+        readonly onError?: (error: unknown) => void;
+    }) => WorldClientReceiptSubscription;
+}
+
+declare const Transform2D: Schema.Struct<{
+    readonly x: Schema.Number;
+    readonly y: Schema.Number;
+    readonly rot: Schema.Number;
+    readonly vx: Schema.optional<Schema.Number>;
+    readonly vy: Schema.optional<Schema.Number>;
+}>;
+
+declare type Transform2D = (typeof Transform2D)["Type"];
+
+declare type WorldBounds = readonly [minimum: WorldPoint, maximum: WorldPoint];
+
+declare interface WorldClientReceiptSubscription {
+    unsubscribe(): void;
+}
+
+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;
+    };
+}
+
+declare interface WorldGeometryDefinition {
+    readonly strategies?: WorldGeometryStrategies | undefined;
+    readonly kind: GeometryKind;
+    readonly static: GeometrySource;
+    readonly chunkSize?: number;
+    readonly dynamic?: {
+        readonly enabled?: boolean | undefined;
+        readonly maxDeltaBytesPerChunk?: number;
+        readonly persist?: {
+            readonly everyMs?: number;
+            readonly onUnload?: boolean;
+        };
+    };
+    readonly collision?: {
+        readonly derive?: 'bitgrid' | 'heightfield' | 'shapes';
+        readonly resolution?: number;
+    };
+    readonly nav?: {
+        readonly derive?: 'grid' | 'none';
+        readonly navBudgetMs?: number;
+        readonly maxAdvanceSteps?: number;
+    };
+    readonly streaming?: {
+        readonly client?: {
+            readonly radiusChunks?: number;
+            readonly prefetchChunks?: number;
+            readonly maxConcurrent?: number | undefined;
+            readonly maxCachedChunks?: number;
+        };
+        readonly cell?: {
+            readonly marginChunks?: number;
+        };
+    };
+    readonly lod?: ReadonlyArray<{
+        readonly beyondChunks: number;
+        readonly fields: ReadonlyArray<string>;
+    }>;
+    readonly budgets?: {
+        readonly maxPreparedChunks?: number;
+        readonly maxPreparedBytes?: number;
+        readonly maxLodLevels?: number;
+        readonly maxRayCells?: number | undefined;
+        readonly maxOverlapTests?: number | undefined;
+    };
+}
+
+declare interface WorldGeometryDescriptor {
+    readonly strategies: GeometryEditStrategies & GeometryDerivationStrategies & GeometryCompactionStrategies & {
+        readonly migrateDelta: GeometryMigrateDelta;
+    };
+    readonly _tag: 'WorldGeometry';
+    readonly kind: GeometryKind;
+    readonly static: GeometrySource;
+    readonly chunkSize: number;
+    readonly chunkSizeRaw: number;
+    readonly dynamic: {
+        readonly enabled: boolean;
+        readonly maxDeltaBytesPerChunk: number;
+        readonly persist: {
+            readonly everyMs: number;
+            readonly onUnload: boolean;
+        };
+    };
+    readonly collision: {
+        readonly derive: 'bitgrid' | 'heightfield' | 'shapes';
+        readonly resolution: number;
+        readonly resolutionRaw: number;
+    };
+    readonly nav: {
+        readonly derive: 'grid' | 'none';
+        readonly navBudgetMs: number;
+        readonly maxAdvanceSteps: number;
+    };
+    readonly streaming: {
+        readonly client: {
+            readonly radiusChunks: number;
+            readonly prefetchChunks: number;
+            readonly maxConcurrent: number;
+            readonly maxCachedChunks: number;
+        };
+        readonly cell: {
+            readonly marginChunks: number;
+        };
+    };
+    readonly lod: ReadonlyArray<{
+        readonly beyondChunks: number;
+        readonly fields: ReadonlyArray<string>;
+    }>;
+    readonly budgets: {
+        readonly maxPreparedChunks: number;
+        readonly maxPreparedBytes: number;
+        readonly maxLodLevels: number;
+        readonly maxRayCells: number;
+        readonly maxOverlapTests: number;
+    };
+}
+
+declare interface WorldGeometryStrategies extends GeometryVersionMigrationStrategies, Partial<GeometryEditStrategies>, Partial<GeometryDerivationStrategies>, Partial<GeometryCompactionStrategies> {
+}
+
+declare interface WorldInstance {
+    readonly id: string;
+    readonly room: string;
+    readonly maxGroups: number;
+    readonly ttl: Duration.Input;
+}
+
+declare type WorldLayerDecision = {
+    readonly kind: 'use';
+    readonly layer: number;
+    readonly wake: boolean;
+} | {
+    readonly kind: 'create';
+    readonly layer: number;
+} | {
+    readonly kind: 'blocked';
+    readonly reason: 'affinity-unavailable' | 'capacity' | 'layer-budget';
+};
+
+declare interface WorldLayering {
+    readonly maxPlayers: number;
+    readonly splitAt: number;
+    readonly mergeBelow: number;
+}
+
+declare interface WorldLayerInput {
+    readonly policy: WorldLayering;
+    readonly layers: ReadonlyArray<WorldLayerObservation>;
+    readonly groupSize: number;
+    /** Actual server-owned party affinity; never silently choose a different layer. */
+    readonly affinity: number | null;
+    readonly maxLayers: number;
+}
+
+declare interface WorldLayerObservation {
+    readonly layer: number;
+    readonly players: number;
+    readonly state: 'live' | 'hibernated' | 'splitting' | 'merging';
+}
+
+declare type WorldLayerPolicy = (input: WorldLayerInput) => WorldLayerDecision;
+
+declare type WorldOnWorldChange = (input: WorldOnWorldChangeInput) => unknown;
+
+declare interface WorldOnWorldChangeInput {
+    readonly sourceWorldId: string;
+    readonly targetWorldId: string;
+    /** Current server-captured character data, never a player's wire state. */
+    readonly sourceData: unknown;
+    /** Actual server-selected target data before this policy. */
+    readonly targetData: unknown;
+}
+
+declare type WorldPoint = readonly [x: number, y: number];
+
+declare interface WorldPosition {
+    readonly zone: string;
+    readonly at: WorldPoint;
+}
+
+declare type WorldTransitionKind = 'cell' | 'layer' | 'zone' | 'world' | 'instance' | 'return' | 'recover';
+
+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 { }