@aethervtt/shard-structure 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Patrick Dias
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,3 @@
-# Temporary Holding Version
+# @aethervtt/shard-structure
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Part of [Shard](https://github.com/aethervtt/shard), a WebGPU-first 2D/3D game engine in TypeScript. See the repository for documentation.

package/dist/bench.d.ts

@@ -0,0 +1,15 @@
+import type { GpuContext } from '@aethervtt/shard-gpu';
+/** One measurement against its budget (0055's acceptance criteria). */
+export interface BenchResult {
+    name: string;
+    value: number;
+    unit: 'ms' | 'bytes' | 'chunks' | 'maps';
+    budget: number;
+    pass: boolean;
+}
+/**
+ * Runs the structure fixtures (Aether's shadow-stress and max scenes) and reports each budget:
+ * mirror sync, max build, wall edit compile, token move and door swing uploads, and shadow maps
+ * on a still frame. `shard bench structure` prints these.
+ */
+export declare function runStructureBench(gpu: GpuContext): Promise<BenchResult[]>;

package/dist/bench.js

@@ -0,0 +1,112 @@
+import { createMirror } from "@aethervtt/shard-mirror";
+import { RenderStats } from "@aethervtt/shard-render";
+import { settle } from "@aethervtt/shard-render/testing";
+import { Structure } from "./compile.js";
+import { DoorLeaf } from "./components.js";
+import { maxScene, shadowStress } from "./fixtures.js";
+import { rig } from "./harness.js";
+const median = (values) => [...values].sort((a, b) => a - b)[values.length >> 1];
+function result(name, value, unit, budget) {
+  return { name, value, unit, budget, pass: value <= budget };
+}
+function empty(docs) {
+  return { ...docs, materials: [], walls: [], openings: [], floors: [], props: [], tokens: [] };
+}
+async function runStructureBench(gpu) {
+  const out = [];
+  {
+    const r = await rig(gpu, { shadows: false });
+    const docs = shadowStress();
+    const mirror = createMirror(r.app.world, {
+      key: (d) => d.id,
+      rev: (d) => d.rev,
+      spawn: (_d, w) => w.spawn(),
+      apply() {
+      }
+    });
+    mirror.sync(docs.walls);
+    for (let i = 0; i < 200; i++) mirror.sync(docs.walls);
+    const times = [];
+    for (let i = 0; i < 400; i++) {
+      const t0 = performance.now();
+      mirror.sync(docs.walls);
+      times.push(performance.now() - t0);
+    }
+    out.push(result("mirror.sync of 5,000 unchanged walls", median(times), "ms", 0.2));
+    await r.dispose();
+  }
+  {
+    const r = await rig(gpu, { shadows: false });
+    const docs = maxScene();
+    const times = [];
+    for (let i = 0; i < 4; i++) {
+      const t0 = performance.now();
+      r.host.sync(docs);
+      r.frame();
+      times.push(performance.now() - t0);
+      r.host.sync(empty(docs));
+      r.frame();
+    }
+    times.shift();
+    out.push(result("max fixture build (sync, compile, first frame)", median(times), "ms", 300));
+    await r.dispose();
+  }
+  {
+    const r = await rig(gpu, { shadowUpdate: "on-change" });
+    const docs = shadowStress();
+    r.host.sync(docs);
+    r.look([10, 20, 24], [10, 0, 8]);
+    await settle(r.app);
+    for (let i = 0; i < 4; i++) r.frame();
+    const world = r.app.world;
+    const stats = world.resource(RenderStats);
+    const state = world.resource(Structure);
+    r.frame();
+    out.push(
+      result("shadow maps drawn on a still frame", stats.lastFrame.shadowMapsRendered, "maps", 0)
+    );
+    const token = docs.tokens[0];
+    docs.tokens[0] = { ...token, rev: token.rev + 1, x: token.x + 70 };
+    r.host.sync(docs);
+    r.frame();
+    out.push(result("token move: scene bytes", stats.lastFrame.sceneBytes, "bytes", 112));
+    r.frame();
+    const door = docs.openings[0];
+    docs.openings[0] = { ...door, rev: door.rev + 1, state: "open" };
+    r.host.sync(docs);
+    let worstBytes = 0;
+    let rebuilt = 0;
+    const leaf = world.query({ with: [DoorLeaf] }).entities().find((e) => world.get(e, DoorLeaf).opening === r.host.openings.entity(door.id));
+    for (let i = 0; i < 40 && world.get(leaf, DoorLeaf).angle < 1; i++) {
+      r.frame();
+      worstBytes = Math.max(worstBytes, stats.lastFrame.sceneBytes);
+      rebuilt += stats.lastFrame.chunksRebuilt;
+    }
+    out.push(result("door swing: chunks rebuilt", rebuilt, "chunks", 0));
+    out.push(result("door swing: scene bytes per frame", worstBytes, "bytes", 112));
+    const k = r.host.k;
+    const times = [];
+    for (let i = 0; i < 12; i++) {
+      const index = 100 + i * 211;
+      const old = docs.walls[index];
+      const ax = old.a.x + 35;
+      const ay = old.a.y + 20;
+      const angle = i * 0.61;
+      docs.walls[index] = {
+        ...old,
+        rev: old.rev + 1,
+        a: { x: ax, y: ay },
+        b: { x: ax + Math.cos(angle) * 3 / k, y: ay + Math.sin(angle) * 3 / k }
+      };
+      r.host.sync(docs);
+      r.frame();
+      times.push(state.last.ms);
+    }
+    out.push(result("3 m wall edit: compile", median(times), "ms", 4));
+    await r.dispose();
+  }
+  return out;
+}
+export {
+  runStructureBench
+};

package/dist/bricks.d.ts

@@ -0,0 +1,27 @@
+import type { AssetRef, World } from '@aethervtt/shard-core';
+import { Texture } from '@aethervtt/shard-texture';
+export interface BrickOptions {
+    seed?: number;
+    /** Brick length and height, metres. Default 0.4 × 0.2 (a VTT-scale block). */
+    brick?: [number, number];
+    /** Mortar joint width, metres. Default 0.025. */
+    mortar?: number;
+    /** Brick colour (linear) and how much each brick varies from it. */
+    color?: [number, number, number];
+    variation?: number;
+    mortarColor?: [number, number, number];
+    /** Texels across one tile. Default 512. */
+    resolution?: number;
+}
+/** The brick textures (albedo, normal, roughness), and the tile's size in metres. */
+export declare function brickTextures(options?: BrickOptions): {
+    albedo: Texture;
+    normal: Texture;
+    metallicRoughness: Texture;
+    tile: [number, number];
+};
+/**
+ * A brick material: its textures in the world's Textures store, tiled so one brick is
+ * `options.brick` metres on structure's metre UVs.
+ */
+export declare function brickMaterial(world: World, options?: BrickOptions): AssetRef<'Material'>;

package/dist/bricks.js

@@ -0,0 +1,98 @@
+import { MaterialAsset, Materials } from "@aethervtt/shard-render";
+import { packMetallicRoughness, Texture, Textures } from "@aethervtt/shard-texture";
+function hash(x, y, seed) {
+  let h = x * 374761393 + y * 668265263 + seed * 2246822519 >>> 0;
+  h = Math.imul(h ^ h >>> 13, 1274126177) >>> 0;
+  return ((h ^ h >>> 16) >>> 0) / 4294967296;
+}
+const toSrgb = (c) => Math.round(255 * Math.min(1, c <= 31308e-7 ? c * 12.92 : 1.055 * c ** (1 / 2.4) - 0.055));
+function brickTextures(options = {}) {
+  const seed = options.seed ?? 1;
+  const [bw, bh] = options.brick ?? [0.4, 0.2];
+  const mortar = options.mortar ?? 0.025;
+  const color = options.color ?? [0.36, 0.13, 0.07];
+  const variation = options.variation ?? 0.25;
+  const mortarColor = options.mortarColor ?? [0.42, 0.4, 0.36];
+  const res = options.resolution ?? 512;
+  const tileW = bw * 2;
+  const tileH = bh * 4;
+  const w = res;
+  const h = Math.max(4, Math.round(res * tileH / tileW));
+  const height = new Float32Array(w * h);
+  const albedo = new Uint8Array(w * h * 4);
+  const rough = new Uint8Array(w * h * 4);
+  for (let row = 0; row < h; row++) {
+    const y = (h - row - 0.5) / h * tileH;
+    const course = Math.floor(y / bh);
+    const shift = course % 2 === 1 ? bw / 2 : 0;
+    for (let col = 0; col < w; col++) {
+      const x = (col + 0.5) / w * tileW;
+      const bx = x + shift;
+      const brick = Math.floor(bx / bw);
+      const fx = bx - brick * bw;
+      const fy = y - course * bh;
+      const edge = Math.min(fx, bw - fx, fy, bh - fy) - mortar / 2;
+      const inBrick = edge > 0;
+      const bevel = Math.min(1, Math.max(0, edge / (mortar * 0.8)));
+      const noise = hash(col, row, seed + 7) * 0.08;
+      const i = row * w + col;
+      height[i] = inBrick ? 0.6 + 0.4 * bevel + noise * bevel : hash(col, row, seed + 11) * 0.05;
+      const id = (brick % 2 + 2) % 2;
+      const tint = 1 + (hash(id, course % 4, seed) - 0.5) * 2 * variation;
+      const speck = 1 + (hash(col, row, seed + 3) - 0.5) * 0.12;
+      const c = inBrick ? color.map((v) => v * tint * speck) : mortarColor.map((v) => v * speck);
+      albedo[i * 4] = toSrgb(c[0]);
+      albedo[i * 4 + 1] = toSrgb(c[1]);
+      albedo[i * 4 + 2] = toSrgb(c[2]);
+      albedo[i * 4 + 3] = 255;
+      const r = inBrick ? 0.78 + noise : 0.95;
+      rough[i * 4] = Math.round(255 * Math.min(1, r));
+    }
+  }
+  const normal = new Uint8Array(w * h * 4);
+  const strength = 2.5;
+  const at = (c, r) => height[(r + h) % h * w + (c + w) % w];
+  for (let row = 0; row < h; row++) {
+    for (let col = 0; col < w; col++) {
+      const dx = (at(col + 1, row) - at(col - 1, row)) * strength;
+      const dUp = (at(col, row - 1) - at(col, row + 1)) * strength;
+      const l = Math.sqrt(dx * dx + dUp * dUp + 1);
+      const i = (row * w + col) * 4;
+      normal[i] = Math.round((-dx / l * 0.5 + 0.5) * 255);
+      normal[i + 1] = Math.round((-dUp / l * 0.5 + 0.5) * 255);
+      normal[i + 2] = Math.round((1 / l * 0.5 + 0.5) * 255);
+      normal[i + 3] = 255;
+    }
+  }
+  return {
+    albedo: Texture.create({ width: w, height: h, usage: "color", mips: [albedo], mipmaps: true }),
+    normal: Texture.create({ width: w, height: h, usage: "normal", mips: [normal], mipmaps: true }),
+    metallicRoughness: packMetallicRoughness({ width: w, height: h, kind: "u8", data: rough }),
+    tile: [tileW, tileH]
+  };
+}
+function brickMaterial(world, options = {}) {
+  const t = brickTextures(options);
+  const textures = world.resource(Textures);
+  const name = `bricks/${options.seed ?? 1}`;
+  const slot = (texture, suffix) => ({
+    texture: textures.add(texture, `${name}/${suffix}`),
+    scale: [1 / t.tile[0], 1 / t.tile[1]],
+    wrap: "repeat"
+  });
+  return world.resource(Materials).add(
+    new MaterialAsset({
+      baseColor: [1, 1, 1, 1],
+      roughness: 1,
+      metallic: 0,
+      baseColorTexture: slot(t.albedo, "albedo"),
+      normalTexture: slot(t.normal, "normal"),
+      metallicRoughnessTexture: slot(t.metallicRoughness, "roughness")
+    }),
+    name
+  );
+}
+export {
+  brickMaterial,
+  brickTextures
+};

package/dist/compile.d.ts

@@ -0,0 +1,292 @@
+import { type AssetRef, type Entity, type World } from '@aethervtt/shard-core';
+import { Mesh } from '@aethervtt/shard-mesh';
+import { type ContactSettings } from './components.js';
+import { ContactQuads } from './contact.js';
+import { ClipScratch, type FloorShape, MeshBuilder, type OpeningShape, type Piece, type WallShape } from './geometry.js';
+type MaterialRef = AssetRef<'Material'>;
+/** The key of the plain frame material: frames and door leaves without one of their own. */
+export declare const FRAME_KEY = "structure:frame";
+interface WallRecord {
+    shape: WallShape;
+    material: string;
+    pieces: Piece[];
+    count: number;
+    /** Material key of each piece. */
+    pieceMaterials: string[];
+    /** (group, chunk) keys its geometry overlaps. */
+    chunks: Set<number>;
+    /** The Level it names (null: none), and the group it draws into (the ground level if the
+     * entity it names isn't a Level). */
+    level: Entity | null;
+    group: Entity;
+    /** Contact shade quads (0068), and the (group, chunk) keys they have area in. */
+    contact: ContactQuads;
+    contactChunks: Set<number>;
+}
+/** A floor or a roof: an outline with its cutouts as holes (0067). */
+interface SlabRecord {
+    kind: 'floor' | 'roof';
+    shape: FloorShape;
+    material: string;
+    /** (group, chunk) keys. */
+    chunks: Set<number>;
+    level: Entity | null;
+    group: Entity;
+    /** Accepted cutouts in ring order (ring i + 1), and the material key of each framed one. */
+    cutouts: Entity[];
+    frameMaterials: string[];
+    /** Roofs: keeps casting while hidden. */
+    shadowWhenHidden: boolean;
+    /** Roofs: its meshes are Cutaway (0070). */
+    cutaway: boolean;
+    /** Roofs: chunk keys of its footprint's bounds, for `roofAt`. */
+    index: number[];
+    /** Everything but its cutouts, and each accepted cutout's outline and frame: when only cutouts
+     * change, only the chunks they cover rebuild. */
+    signature: string;
+    rings: Map<Entity, string>;
+}
+interface OpeningRecord {
+    wall: Entity;
+    kind: 'door' | 'window';
+    offset: number;
+    width: number;
+    height: number;
+    sill: number;
+    frameWidth: number;
+    frameDepth: number;
+    frameMaterial: string;
+    hinge: 'start' | 'end';
+    swing: 'left' | 'right';
+    state: 'closed' | 'open' | 'locked';
+    /** The door leaf or window pane. */
+    leaf: Entity | null;
+    /** How far open the leaf is (0 to 1), and where it's heading. */
+    open: number;
+    target: number;
+}
+interface CutoutRecord {
+    host: Entity;
+    kind: 'hole' | 'hatch' | 'skylight';
+    /** The outline, flat (x, z) pairs. */
+    points: Float64Array;
+    frameWidth: number;
+    frameDepth: number;
+    frameMaterial: string;
+    hinge: number;
+    state: 'closed' | 'open' | 'locked';
+    /** Its ring in its host's shape, or -1 when its host skipped it. */
+    ring: number;
+    /** The hatch leaf or skylight pane, and its mesh. */
+    leaf: Entity | null;
+    mesh: Mesh | null;
+    meshRef: AssetRef<'Mesh'> | null;
+    /** Hatches: the hinge (x, y, z), its axis (unit), and the swing's sign. */
+    pivot: [number, number, number, number, number, number, number];
+    open: number;
+    target: number;
+}
+interface ChunkMesh {
+    entity: Entity;
+    mesh: Mesh;
+    ref: AssetRef<'Mesh'>;
+    triangles: number;
+}
+interface ChunkRecord {
+    group: Entity;
+    x: number;
+    z: number;
+    walls: Set<Entity>;
+    slabs: Set<Entity>;
+    meshes: Map<string, ChunkMesh>;
+    /** Walls with contact shade here, and the chunk's contact mesh (0068). */
+    contacts: Set<Entity>;
+    contact: ChunkMesh | null;
+}
+/** What the last compile that did something did (`structure.describe`). */
+export interface CompileReport {
+    /** Chunks rebuilt, as `[x, z]`, and the group of each. */
+    dirtyChunks: [number, number][];
+    dirtyGroups: Entity[];
+    chunksRebuilt: number;
+    meshesRebuilt: number;
+    /** Chunks whose contact mesh alone was rebuilt (0068): a floor edit, a contact setting. */
+    contactRebuilt: number;
+    /** Those chunks, as `[x, z]`. */
+    contactChunks: [number, number][];
+    ms: number;
+}
+/** Frame demand held while a door or hatch swings (0052). */
+export declare const DOOR_DEMAND = "structure/doors";
+/**
+ * Structure's state: the geometry of every wall, opening, floor, roof and cutout, which (group,
+ * chunk) pairs each overlaps, and the per-material meshes of every one. `structure/compile` keeps
+ * it current. A group is a Level, a Roof, or the ground level (`ground`); its chunk meshes are its
+ * children, so hiding it is one Visibility write (0067).
+ */
+export declare class StructureState {
+    readonly walls: Map<number, WallRecord>;
+    readonly slabs: Map<number, SlabRecord>;
+    readonly openings: Map<number, OpeningRecord>;
+    readonly cutouts: Map<number, CutoutRecord>;
+    /** Openings by host wall entity (including hosts that don't exist yet). */
+    readonly byWall: Map<number, Set<number>>;
+    /** Cutouts by host floor or roof. */
+    readonly byHost: Map<number, Set<number>>;
+    /** Every Level's elevation, to tell a move from an edit that moves nothing. */
+    readonly levels: Map<number, number>;
+    /** Keyed by (group, chunk): see `chunkOf`. */
+    readonly chunks: Map<number, ChunkRecord>;
+    readonly materials: Map<string, MaterialRef>;
+    /** Roofs by the chunks their footprints' bounds overlap (`roofAt`). */
+    readonly roofIndex: Map<number, Set<number>>;
+    /** Group entities by slot; the ground level is slot 0. */
+    readonly groups: Entity[];
+    readonly groupSlots: Map<number, number>;
+    /** Doors and hatches swinging. */
+    readonly moving: Set<number>;
+    /** The ground level's group: pieces without a Level draw under it. */
+    ground: Entity;
+    chunkSize: number;
+    curveTolerance: number;
+    /** The shape each wall last reported a too-tight curve for (reported once per shape). */
+    readonly warned: Map<number, string>;
+    /** The error each cutout last reported (reported once until it changes). */
+    readonly cutoutWarned: Map<number, string>;
+    last: CompileReport;
+    /** Totals since start. */
+    chunksRebuilt: number;
+    compiles: number;
+    defaultMaterial: MaterialRef | undefined;
+    glassMaterial: MaterialRef | undefined;
+    leafMesh: AssetRef<'Mesh'> | undefined;
+    readonly removedWalls: Entity[];
+    readonly removedSlabs: Entity[];
+    readonly removedOpenings: Entity[];
+    readonly removedCutouts: Entity[];
+    readonly removedLevels: Entity[];
+    readonly dirtyWalls: Set<number>;
+    readonly dirtySlabs: Set<number>;
+    readonly dirtyChunks: Set<number>;
+    /** (group, chunk) keys whose contact mesh alone rebuilds. */
+    readonly dirtyContact: Set<number>;
+    /** Walls whose contact quads are recomputed after this compile's walls and slabs. */
+    readonly contactWalls: Set<number>;
+    /** Contact settings as last applied. */
+    contact: ContactSettings;
+    /** StructureSettings.cutawayWalls as last applied (0070). */
+    cutawayWalls: boolean;
+    /** The `StructureSettings.contact` object last merged (a patch replaces it). */
+    contactSeen: object | undefined;
+    contactMaterial: MaterialRef | undefined;
+    readonly contactBuilder: MeshBuilder;
+    readonly contactScratch: ContactQuads;
+    readonly builders: Map<string, MeshBuilder>;
+    readonly scratch: ClipScratch;
+    readonly overlap: Set<number>;
+    readonly region: Set<number>;
+    readonly sortedOpenings: OpeningShape[];
+    readonly world: World;
+    /** Interior lighting's section of `describe` (0069), while interiorLightingPlugin is installed. */
+    describeInterior: (() => unknown) | undefined;
+    constructor(world: World);
+    /** A material's key, registering its ref (the default material for none). */
+    materialKey(ref: MaterialRef | null): string;
+    materialRef(key: string): MaterialRef;
+    builder(key: string): MeshBuilder;
+    /** A group's slot (assigned on first use). */
+    groupSlot(group: Entity): number;
+    /** The (group, chunk) key of chunk `key` in `group`. The ground level's are plain chunk keys. */
+    chunkOf(group: Entity, key: number): number;
+    chunk(composite: number): ChunkRecord;
+    /** Where a piece on `level` draws: the Level, or the ground level when it has none. */
+    groupOf(level: Entity | null): Entity;
+    /** A group's elevation: its Level's, or 0. */
+    baseOf(group: Entity): number;
+    /** Curved walls and how finely each is sampled (0066). */
+    private curves;
+    /** Every group: its kind, level index, chunks and meshes, and whether it's hidden. */
+    private describeGroups;
+    /** Counts for `structure.describe`. */
+    describe(): {
+        walls: number;
+        openings: number;
+        floors: number;
+        roofs: number;
+        cutouts: number;
+        levels: number;
+        chunkSize: number;
+        chunks: number;
+        meshes: number;
+        grid: {
+            min: number[];
+            max: number[];
+            bounds: number[];
+        } | null;
+        groups: {
+            group: Entity;
+            kind: 'ground' | 'level' | 'roof';
+            index: number;
+            chunks: number;
+            meshes: number;
+            contactMeshes: number;
+            hidden: boolean;
+        }[];
+        perChunk: {
+            group: Entity;
+            chunk: [number, number];
+            walls: number;
+            floors: number;
+            meshes: number;
+            contactTriangles: number;
+        }[];
+        contact: {
+            enabled: boolean;
+            meshes: number;
+            triangles: number;
+        };
+        doorsMoving: number;
+        curves: {
+            wall: Entity;
+            samples: number;
+            length: number;
+        }[];
+        warnings: number[];
+        lastCompile: CompileReport;
+        totals: {
+            compiles: number;
+            chunksRebuilt: number;
+        };
+        interior?: unknown;
+    };
+}
+export declare const Structure: import("@aethervtt/shard-core").ResourceDef<StructureState>;
+/** Records despawns and removals for the next compile (observers fire before the value goes). */
+export declare function observeRemovals(world: World, state: StructureState): void;
+/**
+ * The compile: gathers walls, openings, floors, roofs, cutouts and levels changed since its last
+ * run (plus despawns), marks the (group, chunk) pairs their old and new geometry overlap, and
+ * rebuilds exactly those. A door's or hatch's `state` marks nothing. Allocates nothing when
+ * nothing changed.
+ */
+export declare const compileStructure: import("@aethervtt/shard-core").SystemDef<{
+    walls: import("@aethervtt/shard-core").Query;
+    floors: import("@aethervtt/shard-core").Query;
+    roofs: import("@aethervtt/shard-core").Query;
+    openings: import("@aethervtt/shard-core").Query;
+    cutouts: import("@aethervtt/shard-core").Query;
+    levels: import("@aethervtt/shard-core").Query;
+}>;
+/**
+ * The roof whose footprint contains (x, z), through the roofs indexed at that chunk: on an edge
+ * counts, and a point over one of its holes still counts. With `level` (null: the ground level),
+ * only roofs on that level. Ties go to the lowest entity. A host hides the roofs its viewer's
+ * tokens stand under.
+ */
+export declare function roofAt(world: World, x: number, z: number, level?: Entity | null): Entity | undefined;
+/**
+ * Swings door and hatch leaves toward their state over `doorSwingMs` (at once with
+ * `reducedMotion`), holding a frame demand while any moves.
+ */
+export declare const swingDoors: import("@aethervtt/shard-core").SystemDef<undefined>;
+export {};