@forgeax/engine-render 0.1.34 → 0.1.35

package/dist/{chunk-ODZWR6JQ.mjs → chunk-MZ4C7EHF.mjs}

@@ -1,8 +1,1316 @@
-import { CLOUD_EXTINCTION_COEFFICIENT, CLOUD_QUALITY_PROFILES, cloudLayerFormationKey, CloudLayerCacheInvalidError, cloudShadowResolutionForQuality, PointShapeValue, pointShapeFromU32, cloudViewDistanceForQuality } from './chunk-UINHLCZA.mjs';
-import { PointsLinesBudgetExceededError, createVisibilityBudget, PointsLinesStyleUnsupportedError, PointsLinesMaterialUnsupportedError, PointsLinesInvalidStyleError, PointsLinesTopologyMismatchError } from './chunk-WEX45HKH.mjs';
-import { ok, err, deriveMaterialDynamicInputLayout } from '@forgeax/engine-types';
+import { CLOUD_EXTINCTION_COEFFICIENT, MeshFilter, MeshRenderer, Instances, Layer, Visibility, Points, Lines, SortKey, CLOUD_QUALITY_PROFILES, cloudLayerFormationKey, CloudLayerCacheInvalidError, cloudShadowResolutionForQuality, glyphTextLayoutSystem, PointShapeValue, pointShapeFromU32, Camera, CAMERA_PROJECTION_ORTHOGRAPHIC, cloudViewDistanceForQuality } from './chunk-G6HDNGY7.mjs';
+import { SpriteInstances, SpriteRegionOverride, TileLayer, decodeSortScope, Tilemap } from './chunk-X2KA6WHM.mjs';
+import { configureSurface } from './chunk-SGPUJW3F.mjs';
+import { SPRITE_PREMULTIPLIED_ALPHA_BLEND } from './chunk-XSFB7XXQ.mjs';
+import { RenderTargetStateInvalidError, RenderTargetOperationFailedError, RenderTargetCapabilityMissingError, RenderTargetDescriptorInvalidError, GPU_BUFFER_USAGE_COPY_DST, GPU_BUFFER_USAGE_MAP_READ, resolveRenderTargetMaterialSource, createRenderTargetMaterialSource, PointsLinesBudgetExceededError, createVisibilityBudget, PointsLinesStyleUnsupportedError, PointsLinesMaterialUnsupportedError, GPU_TEXTURE_USAGE_RENDER_ATTACHMENT, GPU_TEXTURE_USAGE_TEXTURE_BINDING, GPU_TEXTURE_USAGE_COPY_SRC, PointsLinesInvalidStyleError, PointsLinesTopologyMismatchError } from './chunk-MXTWKZO4.mjs';
+import { ok, err, deriveMaterialDynamicInputLayout, toShared, unwrapHandle } from '@forgeax/engine-types';
 import { validateR32FloatReceipt } from '@forgeax/engine-rhi';
+import { Update } from '@forgeax/engine-ecs';
+import { ChildOf, MorphWeights, registerPropagateTransforms, GlobalTransform, Transform, Children } from '@forgeax/engine-scene';
+import { RuntimeMaterialValue, RuntimeMeshVertices, HANDLE_QUAD, resolveTilesetRuntime } from '@forgeax/engine-assets-runtime';
+import { decodeTileBits } from '@forgeax/engine-graphics-extras';
+import { frustum, mat4 } from '@forgeax/engine-math';
+import { createStateProjection } from '@forgeax/engine-ecs/projection';
+import { Skin } from '@forgeax/engine-skinning';
 
+// src/publication/contract.ts
+function renderPublicationTransfers(packet) {
+  return [
+    packet.upserts.buffer,
+    packet.removed.buffer,
+    packet.transformEntities.buffer,
+    packet.transforms.buffer
+  ];
+}
+var RenderPublicationError = class extends Error {
+  constructor(detail) {
+    super(`render-publication-invalid: ${detail.reason}: ${detail.subject}`);
+    this.detail = detail;
+    this.name = "RenderPublicationError";
+  }
+  detail;
+  code = "render-publication-invalid";
+  expected = "one valid publication for the bound source session and accepted base";
+  hint = "inspect detail.reason; repair the source or start a new session with a complete current baseline";
+};
+
+// src/typed-shadow-atlas.ts
+function resolveDirectionalShadowAtlasGrid(cascadeCount) {
+  const count = Math.max(1, Math.min(4, Math.round(cascadeCount)));
+  if (count === 1) return { columns: 1, rows: 1 };
+  if (count === 2) return { columns: 2, rows: 1 };
+  return { columns: 2, rows: 2 };
+}
+
+// src/record/frame-targets.ts
+function graphExecutionPhase(passName) {
+  if (passName.startsWith("shadowCascade")) return "record/graph-execute/shadow";
+  if (passName.startsWith("point-shadow")) return "record/graph-execute/point-shadow";
+  if (passName.startsWith("spot-shadow")) return "record/graph-execute/spot-shadow";
+  if (passName === "ssr-hiz-seed" || passName.startsWith("ssr-hiz-reduce-")) {
+    return "record/graph-execute/ssr-hiz";
+  }
+  if (passName === "ssr-trace") return "record/graph-execute/ssr-trace";
+  if (passName === "ssr-temporal") return "record/graph-execute/ssr-temporal";
+  if (passName.startsWith("ssr-reflection-mip-")) {
+    return "record/graph-execute/ssr-reflection-mip";
+  }
+  if (passName === "ssr-compose") return "record/graph-execute/ssr-compose";
+  if (passName.startsWith("bloom-downsample-")) {
+    return "record/graph-execute/bloom-downsample";
+  }
+  if (passName.startsWith("bloom-upsample-")) {
+    return "record/graph-execute/bloom-upsample";
+  }
+  switch (passName) {
+    case "cluster-binner-upload":
+    case "cluster-membership-producer":
+      return "record/graph-execute/cluster-binner-upload";
+    case "g-buffer":
+      return "record/graph-execute/g-buffer";
+    case "ssao-calc":
+      return "record/graph-execute/ssao-calc";
+    case "ssao-blur":
+      return "record/graph-execute/ssao-blur";
+    case "lighting":
+      return "record/graph-execute/lighting";
+    case "forward":
+    case "transmission-forward":
+      return "record/graph-execute/forward";
+    case "output-transform":
+      return "record/graph-execute/output-transform";
+    case "present":
+      return "record/graph-execute/present";
+    case "debug-overlay":
+      return "record/graph-execute/debug-overlay";
+    case "shadow":
+      return "record/graph-execute/shadow";
+    case "skybox":
+      return "record/graph-execute/skybox";
+    case "main":
+      return "record/graph-execute/main";
+    case "fxaa":
+      return "record/graph-execute/fxaa";
+    case "bloom-downsample":
+      return "record/graph-execute/bloom-downsample";
+    case "bloom-upsample":
+      return "record/graph-execute/bloom-upsample";
+    case "bloom-composite":
+      return "record/graph-execute/bloom-composite";
+    default:
+      return "record/graph-execute/other";
+  }
+}
+function resolveRenderTargetMipExtent(descriptor, mipLevel) {
+  const mipCount2 = descriptor.mipLevels === 1 ? 1 : Math.floor(Math.log2(Math.max(descriptor.width, descriptor.height))) + 1;
+  const level = Math.max(0, Math.min(mipLevel, mipCount2 - 1));
+  return {
+    width: Math.max(1, descriptor.width >> level),
+    height: Math.max(1, descriptor.height >> level)
+  };
+}
+function acquireSwapChainTarget(internals, pipelineState) {
+  const canvasContext = internals.context;
+  if (canvasContext === null) return null;
+  let currentTextureResult = canvasContext.getCurrentTexture();
+  if (!currentTextureResult.ok) {
+    const configuredDevice = internals.resolveSurfaceDevice?.(internals.device);
+    if (configuredDevice !== void 0 && !configuredDevice.ok) {
+      internals.errorRegistry.fire(configuredDevice.error);
+      internals.healthRegistry.fire({
+        reason: "internal-fault",
+        detail: { message: "surface device resolution failed; current frame skipped" },
+        recoverable: true
+      });
+      return null;
+    }
+    const configured = configureSurface(
+      canvasContext,
+      configuredDevice?.value ?? internals.device,
+      pipelineState.format,
+      pipelineState.colorAttachmentFormat
+    );
+    if (!configured.ok) {
+      internals.errorRegistry.fire(configured.error);
+      internals.healthRegistry.fire({
+        reason: "internal-fault",
+        detail: { message: "surface configure candidate failed; current frame skipped" },
+        recoverable: true
+      });
+      return null;
+    }
+    pipelineState.perPassResources.configured = true;
+    globalThis.__forgeaxSwapChainFormat = pipelineState.format;
+    const retry = canvasContext.getCurrentTexture();
+    if (!retry.ok) {
+      internals.errorRegistry.fire(retry.error);
+      internals.healthRegistry.fire({
+        reason: "internal-fault",
+        detail: {
+          message: "surface-configure-failed after retry: getCurrentTexture failed twice consecutively"
+        },
+        recoverable: false
+      });
+      return null;
+    }
+    currentTextureResult = retry;
+  }
+  const viewDescriptor = pipelineState.colorAttachmentFormat === pipelineState.format ? {} : { format: pipelineState.colorAttachmentFormat };
+  const viewResult = internals.device.createTextureView(currentTextureResult.value, viewDescriptor);
+  if (!viewResult.ok) {
+    internals.errorRegistry.fire(viewResult.error);
+    return null;
+  }
+  return {
+    currentTexture: currentTextureResult.value,
+    view: viewResult.value,
+    targetW: internals.canvas.width | 0,
+    targetH: internals.canvas.height | 0
+  };
+}
+function resolveShadowMapSize(internals, lights) {
+  if (lights.cascadeCount === void 0) return void 0;
+  const requested = lights.shadowMapSize;
+  if (!(requested !== void 0 && requested > 0)) return requested;
+  const cascades = Math.max(1, Math.min(4, Math.round(lights.cascadeCount ?? 1)));
+  const atlasGrid = resolveDirectionalShadowAtlasGrid(cascades);
+  const maxDimension = internals.device.limits.maxTextureDimension2D;
+  if (!(maxDimension > 0)) return Math.floor(requested);
+  const depthTextureDimension = internals.device.caps?.backendKind === "wgpu-webgl2" ? Math.max(1, Math.floor(maxDimension / 2)) : maxDimension;
+  const maxPerTile = Math.max(
+    1,
+    Math.floor(depthTextureDimension / Math.max(atlasGrid.columns, atlasGrid.rows))
+  );
+  return Math.max(1, Math.min(Math.floor(requested), maxPerTile));
+}
+function resolveSpotShadowMapSize(internals, lights) {
+  const requested = lights.spot.find(
+    (spot) => spot.shadowAtlasTile >= 0 && spot.lightViewProj !== void 0
+  )?.mapSize;
+  if (!(requested !== void 0 && requested > 0)) return requested;
+  const maxDimension = internals.device.limits.maxTextureDimension2D;
+  if (!(maxDimension > 0)) return Math.floor(requested);
+  const maxPerTile = Math.max(1, Math.floor(maxDimension / 2));
+  return Math.max(1, Math.min(Math.floor(requested), maxPerTile));
+}
+
+// src/targets/contracts.ts
+var FORMAT_BYTES = {
+  rgba16float: 8,
+  rgba8unorm: 4,
+  "rgba8unorm-srgb": 4
+};
+function mipFactor(mipLevels) {
+  return mipLevels === "full" ? 4 / 3 : 1;
+}
+function estimatedBytes(descriptor) {
+  const layers = descriptor.shape === "cube" ? 6 : 1;
+  const samples = descriptor.sampleCount;
+  const depthBytes = descriptor.depth === void 0 ? 0 : 4;
+  return Math.ceil(
+    descriptor.width * descriptor.height * FORMAT_BYTES[descriptor.format] * layers * samples * mipFactor(descriptor.mipLevels) + descriptor.width * descriptor.height * depthBytes * layers * samples * mipFactor(descriptor.mipLevels)
+  );
+}
+function invalid(field, value, expected) {
+  return {
+    ok: false,
+    error: new RenderTargetDescriptorInvalidError({ field, value, expected })
+  };
+}
+function admitRenderTargetDescriptor(descriptor, limits) {
+  if (!Number.isInteger(descriptor.width) || descriptor.width < 1) {
+    return invalid("width", descriptor.width, "an integer >= 1");
+  }
+  if (!Number.isInteger(descriptor.height) || descriptor.height < 1) {
+    return invalid("height", descriptor.height, "an integer >= 1");
+  }
+  if (descriptor.width > limits.maxTextureDimension2D || descriptor.height > limits.maxTextureDimension2D) {
+    return invalid(
+      "extent",
+      { width: descriptor.width, height: descriptor.height },
+      `width and height <= ${limits.maxTextureDimension2D}`
+    );
+  }
+  if (descriptor.shape === "cube" && descriptor.width !== descriptor.height) {
+    return invalid("shape", descriptor.shape, "cube width === height");
+  }
+  if (!limits.renderableFormats.includes(descriptor.format)) {
+    return {
+      ok: false,
+      error: new RenderTargetCapabilityMissingError({
+        operation: "create",
+        requested: descriptor.format,
+        capability: "renderableFormats",
+        actual: limits.renderableFormats.join(", ")
+      })
+    };
+  }
+  if (!limits.sampleCounts.includes(descriptor.sampleCount)) {
+    return {
+      ok: false,
+      error: new RenderTargetCapabilityMissingError({
+        operation: "create",
+        requested: String(descriptor.sampleCount),
+        capability: "sampleCounts",
+        actual: limits.sampleCounts.join(", ")
+      })
+    };
+  }
+  if (descriptor.depth !== void 0 && !limits.depthFormats.includes(descriptor.depth)) {
+    return {
+      ok: false,
+      error: new RenderTargetCapabilityMissingError({
+        operation: "create",
+        requested: descriptor.depth,
+        capability: "depthFormats",
+        actual: limits.depthFormats.join(", ")
+      })
+    };
+  }
+  const bytes = estimatedBytes(descriptor);
+  if (bytes > limits.maxBytesPerTarget) {
+    return invalid("bytes", bytes, `estimated allocation <= ${limits.maxBytesPerTarget}`);
+  }
+  return { ok: true, value: descriptor };
+}
+
+// src/targets/owner.ts
+function frozenDescriptor(descriptor) {
+  return Object.freeze({ ...descriptor });
+}
+function invalid2(operation, reason, state, generation) {
+  return {
+    ok: false,
+    error: new RenderTargetStateInvalidError({ operation, reason, state, generation })
+  };
+}
+function token() {
+  return Object.freeze({});
+}
+function createRenderTargetOwner(options) {
+  const targets = /* @__PURE__ */ new WeakMap();
+  const requireTarget = (target, operation) => {
+    const state = targets.get(target);
+    if (state === void 0) return invalid2(operation, "foreign-renderer", "destroyed", 0);
+    if (state.rendererId !== options.rendererId) {
+      return invalid2(operation, "foreign-renderer", state.state, state.generation);
+    }
+    if (state.state === "destroyed") {
+      return invalid2(operation, "destroyed", state.state, state.generation);
+    }
+    return { ok: true, value: state };
+  };
+  return {
+    create(descriptor) {
+      const target = token();
+      targets.set(target, {
+        target,
+        rendererId: options.rendererId,
+        state: "uninitialized",
+        generation: 0,
+        descriptor: frozenDescriptor(descriptor),
+        candidate: void 0,
+        retiredGenerations: /* @__PURE__ */ new Set()
+      });
+      return { ok: true, value: target };
+    },
+    stage(target, descriptor) {
+      const found = requireTarget(target, "resize");
+      if (!found.ok) return found;
+      const state = found.value;
+      if (state.state === "rebuilding") {
+        return invalid2("resize", "generation-mismatch", state.state, state.generation);
+      }
+      const candidate = Object.freeze({
+        generation: state.state === "uninitialized" ? options.initialGeneration : state.generation,
+        descriptor: frozenDescriptor(descriptor ?? state.descriptor)
+      });
+      state.candidate = candidate;
+      state.state = "candidate";
+      return { ok: true, value: candidate };
+    },
+    promote(target, generation) {
+      const found = requireTarget(target, "resize");
+      if (!found.ok) return found;
+      const state = found.value;
+      if (state.candidate?.generation !== generation) {
+        return invalid2("resize", "generation-mismatch", state.state, state.generation);
+      }
+      state.descriptor = state.candidate.descriptor;
+      state.generation = generation;
+      state.candidate = void 0;
+      state.state = "active";
+      return { ok: true, value: void 0 };
+    },
+    rejectCandidate(target, generation, stage) {
+      const found = requireTarget(target, "resize");
+      if (!found.ok) return found;
+      const state = found.value;
+      if (state.candidate?.generation !== generation) {
+        return invalid2("resize", "generation-mismatch", state.state, state.generation);
+      }
+      state.candidate = void 0;
+      state.state = state.generation === 0 ? "uninitialized" : "active";
+      return {
+        ok: false,
+        error: new RenderTargetOperationFailedError({
+          operation: "resize",
+          stage,
+          generation,
+          cause: new Error(`candidate ${generation} failed during ${stage}`),
+          recovery: state.generation === 0 ? "retry" : "retain-last-known-good"
+        })
+      };
+    },
+    beginRecovery(target, generation) {
+      const found = requireTarget(target, "resize");
+      if (!found.ok) return found;
+      const state = found.value;
+      if (state.state !== "active" || generation <= state.generation) {
+        return invalid2("resize", "generation-mismatch", state.state, state.generation);
+      }
+      state.generation = generation;
+      state.candidate = void 0;
+      state.state = "rebuilding";
+      return { ok: true, value: void 0 };
+    },
+    finishRecovery(target) {
+      const found = requireTarget(target, "resize");
+      if (!found.ok) return found;
+      const state = found.value;
+      if (state.state !== "rebuilding") {
+        return invalid2("resize", "generation-mismatch", state.state, state.generation);
+      }
+      state.state = "uninitialized";
+      return { ok: true, value: void 0 };
+    },
+    retire(target, generation) {
+      const found = requireTarget(target, "destroy");
+      if (!found.ok) return found;
+      found.value.retiredGenerations.add(generation);
+      return { ok: true, value: void 0 };
+    },
+    destroy(target) {
+      const state = targets.get(target);
+      if (state === void 0) return invalid2("destroy", "foreign-renderer", "destroyed", 0);
+      if (state.rendererId !== options.rendererId) {
+        return invalid2("destroy", "foreign-renderer", state.state, state.generation);
+      }
+      if (state.state === "destroyed") return { ok: true, value: void 0 };
+      state.candidate = void 0;
+      state.state = "destroyed";
+      return { ok: true, value: void 0 };
+    },
+    inspect(target) {
+      const found = requireTarget(target, "inspect");
+      if (!found.ok) return found;
+      const state = found.value;
+      return {
+        ok: true,
+        value: Object.freeze({
+          token: state.target,
+          state: state.state,
+          generation: state.generation,
+          descriptor: state.descriptor,
+          ...state.candidate === void 0 ? {} : { candidate: state.candidate }
+        })
+      };
+    }
+  };
+}
+
+// src/targets/readback.ts
+function invalidTicket(ticket, reason) {
+  return {
+    ok: false,
+    error: new RenderTargetStateInvalidError({
+      operation: "readback",
+      reason,
+      state: reason === "destroyed" ? "destroyed" : "active",
+      generation: ticket.deviceGeneration
+    })
+  };
+}
+function bindRenderTargetReadbackTicket(ticket, receipt) {
+  if (ticket.consumed) return invalidTicket(ticket, "destroyed");
+  if (ticket.frameId !== void 0) {
+    return invalidTicket(ticket, "generation-mismatch");
+  }
+  ticket.frameId = receipt.frameId;
+  ticket.deviceGeneration = receipt.deviceGeneration;
+  return { ok: true, value: void 0 };
+}
+function createRenderTargetReadbackTicket(target, input) {
+  if (input.frameId !== void 0 && (!Number.isInteger(input.frameId) || input.frameId < 0) || !Number.isInteger(input.deviceGeneration) || input.deviceGeneration < 0 || !Number.isInteger(input.mipLevel) || input.mipLevel < 0 || !Number.isInteger(input.width) || input.width < 1 || !Number.isInteger(input.height) || input.height < 1 || !Number.isInteger(input.bytesPerPixel) || input.bytesPerPixel < 1) {
+    return {
+      ok: false,
+      error: new RenderTargetOperationFailedError({
+        operation: "readback",
+        stage: "copy",
+        generation: input.deviceGeneration,
+        cause: new Error("readback dimensions and identity must be non-negative integers"),
+        recovery: "retry"
+      })
+    };
+  }
+  const unalignedRowBytes = input.width * input.bytesPerPixel;
+  const bytesPerRow = Math.ceil(unalignedRowBytes / 256) * 256;
+  return {
+    ok: true,
+    value: {
+      target,
+      frameId: input.frameId,
+      deviceGeneration: input.deviceGeneration,
+      mipLevel: input.mipLevel,
+      ...input.face === void 0 ? {} : { face: input.face },
+      width: input.width,
+      height: input.height,
+      bytesPerRow,
+      byteLength: bytesPerRow * input.height,
+      consumed: false
+    }
+  };
+}
+function completeRenderTargetReadback(ticket, receipt, bytes) {
+  if (ticket.consumed) return invalidTicket(ticket, "destroyed");
+  if (ticket.frameId === void 0 || receipt.frameId !== ticket.frameId || receipt.deviceGeneration !== ticket.deviceGeneration) {
+    return invalidTicket(ticket, "generation-mismatch");
+  }
+  if (bytes.byteLength !== ticket.byteLength) {
+    return {
+      ok: false,
+      error: new RenderTargetOperationFailedError({
+        operation: "readback",
+        stage: "copy",
+        generation: ticket.deviceGeneration,
+        cause: new Error(`expected ${ticket.byteLength} bytes, received ${bytes.byteLength}`),
+        recovery: "retry"
+      })
+    };
+  }
+  ticket.consumed = true;
+  return {
+    ok: true,
+    value: {
+      bytes,
+      frameId: ticket.frameId,
+      deviceGeneration: ticket.deviceGeneration,
+      mipLevel: ticket.mipLevel,
+      ...ticket.face === void 0 ? {} : { face: ticket.face }
+    }
+  };
+}
+
+// src/assembly/render-target-host.ts
+var DEFAULT_LIMITS = {
+  maxTextureDimension2D: 8192,
+  maxBytesPerTarget: 256 * 1024 * 1024,
+  renderableFormats: ["rgba16float", "rgba8unorm", "rgba8unorm-srgb"],
+  sampleCounts: [1, 4],
+  depthFormats: ["depth24plus-stencil8", "depth32float"]
+};
+function opaqueTicket() {
+  return Object.freeze({});
+}
+function bytesPerPixel(format) {
+  return format === "rgba16float" ? 8 : 4;
+}
+function mipCount(descriptor) {
+  return descriptor.mipLevels === 1 ? 1 : Math.floor(Math.log2(Math.max(descriptor.width, descriptor.height))) + 1;
+}
+function makePhysical(device, descriptor, generation) {
+  const layers = descriptor.shape === "cube" ? 6 : 1;
+  const usage = GPU_TEXTURE_USAGE_RENDER_ATTACHMENT | (descriptor.sampled ? GPU_TEXTURE_USAGE_TEXTURE_BINDING : 0) | (descriptor.readback ? GPU_TEXTURE_USAGE_COPY_SRC : 0);
+  const created = device.createTexture({
+    label: `render-target.${generation}`,
+    size: { width: descriptor.width, height: descriptor.height, depthOrArrayLayers: layers },
+    format: descriptor.format,
+    mipLevelCount: mipCount(descriptor),
+    // WebGPU forbids multisampled array textures. The cube is always the
+    // single-sample resolve destination; MSAA capture uses one depth=1 color
+    // texture per face below.
+    sampleCount: 1,
+    dimension: "2d",
+    usage,
+    viewFormats: void 0,
+    textureBindingViewDimension: descriptor.shape === "cube" ? "cube" : void 0
+  });
+  if (!created.ok)
+    return {
+      ok: false,
+      error: new RenderTargetOperationFailedError({
+        operation: "create",
+        stage: "allocation",
+        generation,
+        cause: created.error,
+        recovery: "retry"
+      })
+    };
+  const texture = created.value;
+  const view = device.createTextureView(texture, {
+    dimension: descriptor.shape,
+    baseMipLevel: 0,
+    mipLevelCount: mipCount(descriptor),
+    baseArrayLayer: 0,
+    arrayLayerCount: layers
+  });
+  if (!view.ok)
+    return {
+      ok: false,
+      error: new RenderTargetOperationFailedError({
+        operation: "create",
+        stage: "allocation",
+        generation,
+        cause: view.error,
+        recovery: "retry"
+      })
+    };
+  const mipViews = [];
+  for (let mip = 0; mip < mipCount(descriptor); mip += 1) {
+    const mipView = device.createTextureView(texture, {
+      dimension: descriptor.shape,
+      baseMipLevel: mip,
+      mipLevelCount: 1,
+      baseArrayLayer: 0,
+      arrayLayerCount: layers
+    });
+    if (!mipView.ok)
+      return {
+        ok: false,
+        error: new RenderTargetOperationFailedError({
+          operation: "create",
+          stage: "allocation",
+          generation,
+          cause: mipView.error,
+          recovery: "retry"
+        })
+      };
+    mipViews.push(mipView.value);
+  }
+  const resolveFaceViews = [];
+  for (let face = 0; face < layers; face += 1) {
+    const faceView = device.createTextureView(texture, {
+      dimension: "2d",
+      baseMipLevel: 0,
+      mipLevelCount: 1,
+      baseArrayLayer: face,
+      arrayLayerCount: 1
+    });
+    if (!faceView.ok)
+      return {
+        ok: false,
+        error: new RenderTargetOperationFailedError({
+          operation: "create",
+          stage: "allocation",
+          generation,
+          cause: faceView.error,
+          recovery: "retry"
+        })
+      };
+    resolveFaceViews.push(faceView.value);
+  }
+  const colorTextures = [];
+  const faceViews = [];
+  const depthTextures = [];
+  const depthViews = [];
+  for (let face = 0; face < layers; face += 1) {
+    const depth = device.createTexture({
+      label: `render-target.${generation}.depth.${face}`,
+      size: {
+        width: descriptor.width,
+        height: descriptor.height,
+        depthOrArrayLayers: descriptor.sampleCount === 4 ? 1 : layers
+      },
+      mipLevelCount: 1,
+      sampleCount: descriptor.sampleCount,
+      dimension: "2d",
+      format: "depth24plus-stencil8",
+      usage: GPU_TEXTURE_USAGE_RENDER_ATTACHMENT,
+      viewFormats: void 0,
+      textureBindingViewDimension: void 0
+    });
+    if (!depth.ok)
+      return {
+        ok: false,
+        error: new RenderTargetOperationFailedError({
+          operation: "create",
+          stage: "allocation",
+          generation,
+          cause: depth.error,
+          recovery: "retry"
+        })
+      };
+    const depthView = device.createTextureView(depth.value, {
+      dimension: "2d",
+      baseArrayLayer: descriptor.sampleCount === 4 ? 0 : face,
+      arrayLayerCount: 1
+    });
+    if (!depthView.ok)
+      return {
+        ok: false,
+        error: new RenderTargetOperationFailedError({
+          operation: "create",
+          stage: "allocation",
+          generation,
+          cause: depthView.error,
+          recovery: "retry"
+        })
+      };
+    depthTextures.push(depth.value);
+    depthViews.push(depthView.value);
+  }
+  if (descriptor.sampleCount === 4) {
+    for (let face = 0; face < layers; face += 1) {
+      const msaa = device.createTexture({
+        label: `render-target.${generation}.msaa.${face}`,
+        size: { width: descriptor.width, height: descriptor.height, depthOrArrayLayers: 1 },
+        format: descriptor.format,
+        mipLevelCount: 1,
+        sampleCount: 4,
+        dimension: "2d",
+        usage: GPU_TEXTURE_USAGE_RENDER_ATTACHMENT,
+        viewFormats: void 0,
+        textureBindingViewDimension: void 0
+      });
+      if (!msaa.ok)
+        return {
+          ok: false,
+          error: new RenderTargetOperationFailedError({
+            operation: "create",
+            stage: "allocation",
+            generation,
+            cause: msaa.error,
+            recovery: "retry"
+          })
+        };
+      const msaaView = device.createTextureView(msaa.value, {
+        dimension: "2d",
+        baseMipLevel: 0,
+        mipLevelCount: 1,
+        baseArrayLayer: 0,
+        arrayLayerCount: 1
+      });
+      if (!msaaView.ok)
+        return {
+          ok: false,
+          error: new RenderTargetOperationFailedError({
+            operation: "create",
+            stage: "allocation",
+            generation,
+            cause: msaaView.error,
+            recovery: "retry"
+          })
+        };
+      colorTextures.push(msaa.value);
+      faceViews.push(msaaView.value);
+    }
+  } else {
+    for (let face = 0; face < layers; face += 1) {
+      colorTextures.push(texture);
+      faceViews.push(resolveFaceViews[face] ?? view.value);
+    }
+  }
+  return {
+    ok: true,
+    value: {
+      generation,
+      descriptor,
+      texture,
+      view: view.value,
+      mipViews,
+      colorTextures,
+      faceViews,
+      depthTextures,
+      depthViews,
+      ...descriptor.sampleCount === 4 ? { resolveTexture: texture } : {},
+      resolveView: view.value,
+      resolveFaceViews
+    }
+  };
+}
+function destroyPhysical(device, physical) {
+  if (device === void 0 || physical === void 0) return;
+  const textures = /* @__PURE__ */ new Set();
+  textures.add(physical.texture);
+  if (physical.resolveTexture !== void 0) textures.add(physical.resolveTexture);
+  for (const texture of physical.colorTextures) textures.add(texture);
+  for (const texture of physical.depthTextures) textures.add(texture);
+  for (const texture of textures) device.destroyTexture(texture);
+}
+function createRenderTargetHost(options = {}) {
+  let disposed = false;
+  const limits = options.limits ?? DEFAULT_LIMITS;
+  const owner = createRenderTargetOwner({
+    rendererId: options.rendererId ?? /* @__PURE__ */ Symbol("renderer"),
+    initialGeneration: options.initialGeneration ?? 0
+  });
+  const targets = /* @__PURE__ */ new Set();
+  const staged = /* @__PURE__ */ new Set();
+  const activePhysical = /* @__PURE__ */ new WeakMap();
+  const candidatePhysical = /* @__PURE__ */ new WeakMap();
+  const sources = /* @__PURE__ */ new WeakMap();
+  const readbacks = /* @__PURE__ */ new WeakMap();
+  const readbackRecords = /* @__PURE__ */ new Set();
+  const currentGeneration = () => options.getGeneration?.() ?? options.initialGeneration ?? 0;
+  const stagePhysical = (target, descriptor) => {
+    const stagedTarget = owner.stage(target, descriptor);
+    if (!stagedTarget.ok) return stagedTarget;
+    const device = options.getDevice?.();
+    if (device === void 0) {
+      staged.add(target);
+      return { ok: true, value: void 0 };
+    }
+    const physical = makePhysical(
+      device,
+      stagedTarget.value.descriptor,
+      stagedTarget.value.generation
+    );
+    if (!physical.ok) {
+      owner.rejectCandidate(target, stagedTarget.value.generation, "allocation");
+      return physical;
+    }
+    candidatePhysical.set(target, physical.value);
+    staged.add(target);
+    return { ok: true, value: void 0 };
+  };
+  return Object.freeze({
+    owner: "renderer",
+    descriptions() {
+      return [...targets].map((target) => {
+        const state = owner.inspect(target);
+        if (!state.ok) throw state.error;
+        return { target, descriptor: state.value.candidate?.descriptor ?? state.value.descriptor };
+      });
+    },
+    createRenderTarget(descriptor) {
+      if (disposed) {
+        return {
+          ok: false,
+          error: new RenderTargetStateInvalidError({
+            operation: "inspect",
+            reason: "destroyed",
+            state: "destroyed",
+            generation: currentGeneration()
+          })
+        };
+      }
+      const admitted = admitRenderTargetDescriptor(descriptor, limits);
+      if (!admitted.ok) return admitted;
+      const created = owner.create(admitted.value);
+      if (created.ok) targets.add(created.value);
+      return created;
+    },
+    resizeRenderTarget(target, descriptor) {
+      const admitted = admitRenderTargetDescriptor(descriptor, limits);
+      if (!admitted.ok) return admitted;
+      return stagePhysical(target, admitted.value);
+    },
+    createRenderTargetTextureSource(target, sourceOptions) {
+      const inspected = owner.inspect(target);
+      if (!inspected.ok) return inspected;
+      if (!inspected.value.descriptor.sampled) {
+        return {
+          ok: false,
+          error: new RenderTargetCapabilityMissingError({
+            operation: "source",
+            requested: "sampled=true",
+            capability: "sampled",
+            actual: "false"
+          })
+        };
+      }
+      if (sourceOptions.dimension !== inspected.value.descriptor.shape) {
+        return {
+          ok: false,
+          error: new RenderTargetDescriptorInvalidError({
+            field: "dimension",
+            value: sourceOptions.dimension,
+            expected: `dimension matches ${inspected.value.descriptor.shape}`
+          })
+        };
+      }
+      if (!Number.isInteger(sourceOptions.mipLevel) || sourceOptions.mipLevel < 0 || inspected.value.descriptor.mipLevels === 1 && sourceOptions.mipLevel !== 0) {
+        return {
+          ok: false,
+          error: new RenderTargetDescriptorInvalidError({
+            field: "mipLevel",
+            value: sourceOptions.mipLevel,
+            expected: "an admitted mip level for the target"
+          })
+        };
+      }
+      const binding = createRenderTargetMaterialSource(target, inspected.value.descriptor, {
+        ...sourceOptions,
+        generation: inspected.value.generation
+      });
+      if (!binding.ok) return binding;
+      sources.set(binding.value.source, binding.value);
+      return { ok: true, value: binding.value.source };
+    },
+    resolveRenderTargetTextureSource(source) {
+      const binding = sources.get(source) ?? resolveRenderTargetMaterialSource(source);
+      if (binding === void 0) return void 0;
+      const physical = activePhysical.get(binding.target);
+      if (physical === void 0) return binding;
+      const view = physical.mipViews[binding.view.mipLevel] ?? (binding.shape === "cube" ? physical.view : physical.resolveView);
+      if (binding.generation !== physical.generation) return binding;
+      return { ...binding, textureView: view };
+    },
+    requestTargetReadback(target, request) {
+      const inspected = owner.inspect(target);
+      if (!inspected.ok) return inspected;
+      if (!inspected.value.descriptor.readback) {
+        return {
+          ok: false,
+          error: new RenderTargetCapabilityMissingError({
+            operation: "readback",
+            requested: "readback=true",
+            capability: "readback",
+            actual: "false"
+          })
+        };
+      }
+      if (!Number.isInteger(request.mipLevel) || request.mipLevel < 0) {
+        return {
+          ok: false,
+          error: new RenderTargetDescriptorInvalidError({
+            field: "mipLevel",
+            value: request.mipLevel,
+            expected: "a non-negative integer"
+          })
+        };
+      }
+      const mipCount2 = inspected.value.descriptor.mipLevels === 1 ? 1 : Math.floor(
+        Math.log2(
+          Math.max(inspected.value.descriptor.width, inspected.value.descriptor.height)
+        )
+      ) + 1;
+      if (request.mipLevel >= mipCount2) {
+        return {
+          ok: false,
+          error: new RenderTargetDescriptorInvalidError({
+            field: "mipLevel",
+            value: request.mipLevel,
+            expected: `mipLevel < ${mipCount2}`
+          })
+        };
+      }
+      if (request.face !== void 0 && (!Number.isInteger(request.face) || request.face < 0 || request.face > 5 || inspected.value.descriptor.shape !== "cube")) {
+        return {
+          ok: false,
+          error: new RenderTargetDescriptorInvalidError({
+            field: "face",
+            value: request.face,
+            expected: inspected.value.descriptor.shape === "cube" ? "an integer in [0, 5]" : "omitted for a 2d target"
+          })
+        };
+      }
+      const ticket = opaqueTicket();
+      const extent = resolveRenderTargetMipExtent(inspected.value.descriptor, request.mipLevel);
+      const buffer = options.getDevice?.()?.createBuffer({
+        label: `render-target-readback.${request.mipLevel}.${request.face ?? 0}`,
+        size: Math.ceil(extent.width * bytesPerPixel(inspected.value.descriptor.format) / 256) * 256 * extent.height,
+        usage: GPU_BUFFER_USAGE_COPY_DST | GPU_BUFFER_USAGE_MAP_READ,
+        mappedAtCreation: false
+      });
+      if (buffer !== void 0 && !buffer.ok) {
+        return {
+          ok: false,
+          error: new RenderTargetOperationFailedError({
+            operation: "readback",
+            stage: "allocation",
+            generation: inspected.value.generation,
+            cause: buffer.error,
+            recovery: "retry"
+          })
+        };
+      }
+      const internalTicket = createRenderTargetReadbackTicket(target, {
+        deviceGeneration: inspected.value.generation,
+        mipLevel: request.mipLevel,
+        ...request.face === void 0 ? {} : { face: request.face },
+        width: extent.width,
+        height: extent.height,
+        bytesPerPixel: bytesPerPixel(inspected.value.descriptor.format)
+      });
+      if (!internalTicket.ok) return internalTicket;
+      const record = {
+        target,
+        request,
+        ticket: internalTicket.value,
+        ...buffer === void 0 ? {} : { buffer: buffer.value },
+        encoded: false
+      };
+      readbacks.set(ticket, record);
+      readbackRecords.add(record);
+      return { ok: true, value: ticket };
+    },
+    async observeTargetReadbacks(receipt, tickets) {
+      const results = [];
+      for (const publicTicket of tickets) {
+        const record = readbacks.get(publicTicket);
+        if (record === void 0) {
+          return {
+            ok: false,
+            error: new RenderTargetStateInvalidError({
+              operation: "readback",
+              reason: "foreign-renderer",
+              state: "destroyed",
+              generation: receipt.deviceGeneration
+            })
+          };
+        }
+        const inspected = owner.inspect(record.target);
+        if (!inspected.ok) return inspected;
+        if (inspected.value.state !== "active") {
+          return {
+            ok: false,
+            error: new RenderTargetStateInvalidError({
+              operation: "readback",
+              reason: "uninitialized",
+              state: inspected.value.state,
+              generation: inspected.value.generation
+            })
+          };
+        }
+        if (inspected.value.generation !== receipt.deviceGeneration) {
+          return {
+            ok: false,
+            error: new RenderTargetStateInvalidError({
+              operation: "readback",
+              reason: "generation-mismatch",
+              state: inspected.value.state,
+              generation: inspected.value.generation
+            })
+          };
+        }
+        const bound = bindRenderTargetReadbackTicket(record.ticket, receipt);
+        if (!bound.ok) return bound;
+        let bytes = new Uint8Array(record.ticket.byteLength);
+        if (record.buffer !== void 0 && typeof record.buffer.mapAsync === "function") {
+          const mapped = await record.buffer.mapAsync(1);
+          if (!mapped.ok) {
+            return {
+              ok: false,
+              error: new RenderTargetOperationFailedError({
+                operation: "readback",
+                stage: "copy",
+                generation: receipt.deviceGeneration,
+                cause: mapped.error,
+                recovery: "retry"
+              })
+            };
+          }
+          const range = mapped.value.getMappedRange();
+          if (!range.ok) {
+            return {
+              ok: false,
+              error: new RenderTargetOperationFailedError({
+                operation: "readback",
+                stage: "copy",
+                generation: receipt.deviceGeneration,
+                cause: range.error,
+                recovery: "retry"
+              })
+            };
+          }
+          bytes = new Uint8Array(range.value.slice(0));
+          mapped.value.unmap();
+        }
+        const completed = completeRenderTargetReadback(record.ticket, receipt, bytes);
+        if (!completed.ok) return completed;
+        results.push({
+          ticket: publicTicket,
+          bytes: completed.value.bytes,
+          frameId: completed.value.frameId,
+          deviceGeneration: completed.value.deviceGeneration,
+          mipLevel: completed.value.mipLevel,
+          ...completed.value.face === void 0 ? {} : { face: completed.value.face },
+          bytesPerRow: record.ticket.bytesPerRow,
+          byteLength: record.ticket.byteLength
+        });
+      }
+      return { ok: true, value: Object.freeze(results) };
+    },
+    destroyRenderTarget(target) {
+      const destroyed = owner.destroy(target);
+      if (destroyed.ok) {
+        destroyPhysical(options.getDevice?.(), activePhysical.get(target));
+        destroyPhysical(options.getDevice?.(), candidatePhysical.get(target));
+        activePhysical.delete(target);
+        candidatePhysical.delete(target);
+        for (const record of readbackRecords) {
+          if (record.target !== target) continue;
+          if (record.buffer !== void 0) options.getDevice?.()?.destroyBuffer(record.buffer);
+          readbacks.delete(record.ticket);
+          readbackRecords.delete(record);
+        }
+        targets.delete(target);
+      }
+      return destroyed;
+    },
+    beginFrame() {
+      if (disposed) return;
+      for (const target of targets) {
+        const inspected = owner.inspect(target);
+        if (!inspected.ok || inspected.value.state === "active" || inspected.value.state === "candidate") {
+          continue;
+        }
+        stagePhysical(target);
+      }
+    },
+    onFrameSubmitted(completed = Promise.resolve({ ok: true, value: void 0 })) {
+      if (disposed) return;
+      const submittedTargets = [...staged];
+      staged.clear();
+      void completed.then((result) => {
+        for (const target of submittedTargets) {
+          const candidate = owner.inspect(target);
+          if (!candidate.ok || candidate.value.candidate === void 0) continue;
+          if (!result.ok) {
+            owner.rejectCandidate(target, candidate.value.candidate.generation, "submit");
+            destroyPhysical(options.getDevice?.(), candidatePhysical.get(target));
+            candidatePhysical.delete(target);
+            continue;
+          }
+          if (options.canPromoteTarget?.(target) === false) {
+            staged.add(target);
+            continue;
+          }
+          const generation = candidate.value.candidate.generation;
+          const physical = candidatePhysical.get(target);
+          if (physical === void 0) {
+            owner.rejectCandidate(target, generation, "submit");
+            continue;
+          }
+          const promoted = owner.promote(target, generation);
+          if (!promoted.ok) {
+            destroyPhysical(options.getDevice?.(), physical);
+            candidatePhysical.delete(target);
+            continue;
+          }
+          const previous = activePhysical.get(target);
+          activePhysical.set(target, physical);
+          candidatePhysical.delete(target);
+          destroyPhysical(options.getDevice?.(), previous);
+        }
+      });
+    },
+    getPhysicalTarget(target) {
+      return candidatePhysical.get(target) ?? activePhysical.get(target);
+    },
+    encodePendingReadbacks(encoder, faces) {
+      for (const record of readbackRecords) {
+        if (record.encoded || record.buffer === void 0) continue;
+        if (faces !== void 0 && record.ticket.face !== void 0 && !faces.includes(record.ticket.face)) {
+          continue;
+        }
+        const candidate = candidatePhysical.get(record.target);
+        const physical = faces !== void 0 && candidate !== void 0 && record.ticket.face !== void 0 && faces.includes(record.ticket.face) ? candidate : activePhysical.get(record.target);
+        if (physical === void 0) continue;
+        const source = physical.resolveTexture ?? physical.texture;
+        encoder.copyTextureToBuffer(
+          {
+            texture: source,
+            mipLevel: record.ticket.mipLevel,
+            origin: { x: 0, y: 0, z: record.ticket.face ?? 0 }
+          },
+          {
+            buffer: record.buffer,
+            bytesPerRow: record.ticket.bytesPerRow,
+            rowsPerImage: record.ticket.height
+          },
+          [record.ticket.width, record.ticket.height, 1]
+        );
+        record.encoded = true;
+      }
+    },
+    recover() {
+      if (disposed) return;
+      const generation = currentGeneration();
+      for (const target of targets) {
+        const inspected = owner.inspect(target);
+        if (!inspected.ok || inspected.value.state !== "active") continue;
+        destroyPhysical(options.getDevice?.(), activePhysical.get(target));
+        destroyPhysical(options.getDevice?.(), candidatePhysical.get(target));
+        activePhysical.delete(target);
+        candidatePhysical.delete(target);
+        for (const record of readbackRecords) {
+          if (record.target !== target) continue;
+          if (record.buffer !== void 0) options.getDevice?.()?.destroyBuffer(record.buffer);
+          readbacks.delete(record.ticket);
+          readbackRecords.delete(record);
+        }
+        const begun = owner.beginRecovery(target, generation);
+        if (begun.ok) owner.finishRecovery(target);
+      }
+    },
+    dispose() {
+      disposed = true;
+      for (const target of [...targets]) {
+        destroyPhysical(options.getDevice?.(), activePhysical.get(target));
+        destroyPhysical(options.getDevice?.(), candidatePhysical.get(target));
+        for (const record of readbackRecords) {
+          if (record.target !== target) continue;
+          if (record.buffer !== void 0) options.getDevice?.()?.destroyBuffer(record.buffer);
+          readbacks.delete(record.ticket);
+          readbackRecords.delete(record);
+        }
+        activePhysical.delete(target);
+        candidatePhysical.delete(target);
+        owner.destroy(target);
+      }
+      targets.clear();
+      staged.clear();
+      readbackRecords.clear();
+    }
+  });
+}
+
+// src/publication/targets.ts
+var RenderPublicationTargetOwner = class {
+  host = createRenderTargetHost();
+  ids = /* @__PURE__ */ new WeakMap();
+  nextId = 0;
+  authoring = this.host;
+  snapshot() {
+    return this.host.descriptions().map(({ target, descriptor }) => {
+      let id = this.ids.get(target);
+      if (id === void 0) {
+        id = ++this.nextId;
+        this.ids.set(target, id);
+      }
+      return { id, token: target, descriptor };
+    });
+  }
+  dispose() {
+    this.host.dispose();
+  }
+};
+function publicationTargetSources(templates) {
+  const sources = /* @__PURE__ */ new Map();
+  for (const template of templates)
+    for (const material of template.snapshot.materials) {
+      for (const source of material.textureSources?.values() ?? []) {
+        if (sources.has(source)) continue;
+        const binding = resolveRenderTargetMaterialSource(source);
+        if (binding === void 0)
+          throw new RenderPublicationError({
+            reason: "shape",
+            subject: "unknown material target source"
+          });
+        sources.set(source, {
+          token: source,
+          target: binding.target,
+          options: {
+            aspect: "color",
+            dimension: binding.view.dimension,
+            mipLevel: binding.view.mipLevel
+          }
+        });
+      }
+    }
+  return [...sources.values()];
+}
+var RenderPublicationTargetReceiver = class {
+  constructor(host) {
+    this.host = host;
+  }
+  host;
+  targets = /* @__PURE__ */ new Map();
+  apply(input) {
+    const packet = input.packet;
+    if (packet.targets.length === 0 && packet.targetSources.length === 0 && this.targets.size === 0)
+      return input;
+    const tokens = /* @__PURE__ */ new Map();
+    const records = /* @__PURE__ */ new Map();
+    const active = new Set(packet.targets.map((row) => row.id));
+    for (const [id, record] of this.targets)
+      if (!active.has(id)) {
+        const destroyed = this.host.destroyRenderTarget(record.target);
+        if (!destroyed.ok) throw destroyed.error;
+        this.targets.delete(id);
+      }
+    for (const row of packet.targets) {
+      let record = this.targets.get(row.id);
+      if (record === void 0) {
+        const created = this.host.createRenderTarget(row.descriptor);
+        if (!created.ok) throw created.error;
+        record = { target: created.value, descriptor: row.descriptor, sources: /* @__PURE__ */ new Map() };
+        this.targets.set(row.id, record);
+      } else if (JSON.stringify(record.descriptor) !== JSON.stringify(row.descriptor)) {
+        const resized = this.host.resizeRenderTarget(record.target, row.descriptor);
+        if (!resized.ok) throw resized.error;
+        record.descriptor = row.descriptor;
+        record.sources.clear();
+      }
+      tokens.set(row.token, record.target);
+      records.set(row.token, record);
+    }
+    const resolve = (token2) => {
+      const target = tokens.get(token2);
+      if (target === void 0)
+        throw new RenderPublicationError({ reason: "shape", subject: "missing target descriptor" });
+      return target;
+    };
+    const sources = /* @__PURE__ */ new Map();
+    for (const row of packet.targetSources) {
+      const record = records.get(row.target);
+      if (record === void 0)
+        throw new RenderPublicationError({ reason: "shape", subject: "missing material target" });
+      const key = JSON.stringify(row.options);
+      let source = record.sources.get(key);
+      if (source === void 0) {
+        const created = this.host.createRenderTargetTextureSource(record.target, row.options);
+        if (!created.ok) throw created.error;
+        source = created.value;
+        record.sources.set(key, source);
+      }
+      sources.set(row.token, source);
+    }
+    const camera = (row) => row.target === void 0 ? row : { ...row, target: resolve(row.target) };
+    const renderables = input.frame.renderables.map((row) => {
+      const materials = row.materials.map((material) => {
+        if (material.textureSources === void 0) return material;
+        const textureSources = new Map(
+          [...material.textureSources].map(([name, token2]) => {
+            const source = sources.get(token2);
+            if (source === void 0)
+              throw new RenderPublicationError({
+                reason: "shape",
+                subject: "missing material target source"
+              });
+            return [name, source];
+          })
+        );
+        return { ...material, textureSources };
+      });
+      const first = row.materials.indexOf(row.material);
+      return { ...row, materials, material: materials[Math.max(0, first)] ?? row.material };
+    });
+    const snapshots = new Map(renderables.map((row) => [row.entityKey, row]));
+    return {
+      ...input,
+      frame: {
+        ...input.frame,
+        renderables,
+        cameras: input.frame.cameras.map(camera),
+        auxiliaryCameras: input.frame.auxiliaryCameras.map(camera),
+        cubeCameras: input.frame.cubeCameras.map(camera)
+      },
+      operations: input.operations.map((operation) => {
+        if (operation.kind === "remove" || operation.snapshot === void 0) return operation;
+        const snapshot = snapshots.get(operation.entityKey);
+        if (snapshot === void 0)
+          throw new RenderPublicationError({
+            reason: "shape",
+            subject: "missing remapped snapshot"
+          });
+        return { ...operation, snapshot };
+      })
+    };
+  }
+};
 var BARREL_DISTORTION_POST_PROCESS_ID = "fullscreen.forgeax.barrel-distortion";
 var BARREL_DISTORTION_FEATURE_IDENTITY = BARREL_DISTORTION_POST_PROCESS_ID;
 var BARREL_DISTORTION_WGSL_COORDINATE = (
@@ -3482,7 +4790,7 @@ function fieldWidth(type) {
 function finiteNumber(value) {
   return typeof value === "number" && Number.isFinite(value);
 }
-function invalid(code, operation, expected, actual, field, page) {
+function invalid3(code, operation, expected, actual, field, page) {
   return new DynamicInputError(code, {
     operation,
     expected,
@@ -3523,7 +4831,7 @@ var ReadonlyDynamicInputPage = class _ReadonlyDynamicInputPage {
   static create(input) {
     if (input.sourceId.length === 0 || !Number.isSafeInteger(input.pageId) || input.pageId < 0) {
       return err(
-        invalid(
+        invalid3(
           "invalid-schema",
           "create",
           "sourceId is non-empty and pageId is non-negative",
@@ -3534,7 +4842,7 @@ var ReadonlyDynamicInputPage = class _ReadonlyDynamicInputPage {
     const layout = deriveMaterialDynamicInputLayout(input.schema);
     if (!layout.ok) {
       return err(
-        invalid(
+        invalid3(
           "invalid-schema",
           "create",
           layout.error.expected,
@@ -3568,7 +4876,7 @@ var ReadonlyDynamicInputPage = class _ReadonlyDynamicInputPage {
     if (!live.ok) return live;
     if (!Number.isSafeInteger(index) || index < 0 || index >= this.schema.maxRecords) {
       return err(
-        invalid(
+        invalid3(
           "range-overflow",
           "write",
           `record index is within [0, ${this.schema.maxRecords})`,
@@ -3585,7 +4893,7 @@ var ReadonlyDynamicInputPage = class _ReadonlyDynamicInputPage {
       const value = values[field.name];
       if (value === void 0) {
         return err(
-          invalid(
+          invalid3(
             "invalid-record",
             "write",
             `record contains field ${field.name}`,
@@ -3599,7 +4907,7 @@ var ReadonlyDynamicInputPage = class _ReadonlyDynamicInputPage {
       const numbers = typeof value === "number" ? [value] : value;
       if (numbers.length !== width || numbers.some((candidate) => !finiteNumber(candidate))) {
         return err(
-          invalid(
+          invalid3(
             "invalid-record",
             "write",
             `${field.name} is a finite ${field.type}`,
@@ -3611,7 +4919,7 @@ var ReadonlyDynamicInputPage = class _ReadonlyDynamicInputPage {
       }
       if (field.type === "u32" && (!Number.isInteger(numbers[0]) || numbers[0] < 0 || numbers[0] > 4294967295)) {
         return err(
-          invalid(
+          invalid3(
             "invalid-record",
             "write",
             `${field.name} is an unsigned 32-bit integer`,
@@ -3638,7 +4946,7 @@ var ReadonlyDynamicInputPage = class _ReadonlyDynamicInputPage {
     if (!live.ok) return live;
     if (input.domain.length === 0) {
       return err(
-        invalid(
+        invalid3(
           "domain-overflow",
           "reserve",
           "domain is a non-empty identity",
@@ -3650,7 +4958,7 @@ var ReadonlyDynamicInputPage = class _ReadonlyDynamicInputPage {
     }
     if (!this.domains.has(input.domain) && this.domains.size >= this.schema.maxDomains) {
       return err(
-        invalid(
+        invalid3(
           "domain-overflow",
           "reserve",
           `at most ${this.schema.maxDomains} domains are active`,
@@ -3662,7 +4970,7 @@ var ReadonlyDynamicInputPage = class _ReadonlyDynamicInputPage {
     }
     if (!Number.isSafeInteger(input.instanceIndex) || input.instanceIndex < 0 || input.instanceIndex > 4294967295) {
       return err(
-        invalid(
+        invalid3(
           "range-overflow",
           "reserve",
           "instance index is an exact unsigned 32-bit integer",
@@ -3674,7 +4982,7 @@ var ReadonlyDynamicInputPage = class _ReadonlyDynamicInputPage {
     }
     if (input.member.worldIdentity.length === 0 || !Number.isSafeInteger(input.member.entityKey) || input.member.entityKey < 0 || input.member.entityKey > 4294967295 || !Number.isSafeInteger(input.member.drawItemIndex) || input.member.drawItemIndex < 0 || input.member.drawItemIndex > 4294967295 || !Number.isSafeInteger(input.member.instanceOrdinal) || input.member.instanceOrdinal < 0 || input.member.instanceOrdinal > 4294967295) {
       return err(
-        invalid(
+        invalid3(
           "range-overflow",
           "reserve",
           "member is a stable World identity plus exact unsigned 32-bit entity, draw-item, and instance identities",
@@ -3686,7 +4994,7 @@ var ReadonlyDynamicInputPage = class _ReadonlyDynamicInputPage {
     }
     if (!Number.isSafeInteger(input.recordStart) || !Number.isSafeInteger(input.recordCount) || input.recordStart < 0 || input.recordCount <= 0 || input.recordStart + input.recordCount > this.schema.maxRecords) {
       return err(
-        invalid(
+        invalid3(
           "range-overflow",
           "reserve",
           "record range and instance index fit the declared page",
@@ -3745,7 +5053,7 @@ var ReadonlyDynamicInputPage = class _ReadonlyDynamicInputPage {
     if (!live.ok) return live;
     if (!this.ownedUploads.has(receipt) || receipt.sourceId !== this.sourceId || receipt.pageId !== this.pageId || receipt.bufferGeneration !== this.bufferGenerationValue || receipt.deviceGeneration !== this.deviceGenerationValue || receipt.contentRevision !== this.contentRevisionValue) {
       return err(
-        invalid(
+        invalid3(
           "stale-generation",
           "upload",
           "the upload receipt still describes the current page revision and generation",
@@ -3779,7 +5087,7 @@ var ReadonlyDynamicInputPage = class _ReadonlyDynamicInputPage {
     if (!live.ok) return live;
     if (!this.ownedRanges.has(range) || range.sourceId !== this.sourceId || range.pageId !== this.pageId || range.bufferGeneration !== this.bufferGenerationValue || range.deviceGeneration !== this.deviceGenerationValue || range.recordStart < 0 || range.recordCount <= 0 || range.recordStart + range.recordCount > this.schema.maxRecords) {
       return err(
-        invalid(
+        invalid3(
           "stale-generation",
           "consume",
           "range belongs to this current page generation",
@@ -3791,7 +5099,7 @@ var ReadonlyDynamicInputPage = class _ReadonlyDynamicInputPage {
     }
     if (this.uploadedRevisionValue < range.contentRevision) {
       return err(
-        invalid(
+        invalid3(
           "not-uploaded",
           "consume",
           "range content revision was uploaded before consumption",
@@ -3809,7 +5117,7 @@ var ReadonlyDynamicInputPage = class _ReadonlyDynamicInputPage {
     if (!live.ok) return live;
     if (!Number.isSafeInteger(deviceGeneration) || deviceGeneration < 0) {
       return err(
-        invalid(
+        invalid3(
           "stale-generation",
           "reconfigure",
           "deviceGeneration is a non-negative safe integer",
@@ -3822,7 +5130,7 @@ var ReadonlyDynamicInputPage = class _ReadonlyDynamicInputPage {
     const rendererInitialGeneration = this.bufferGenerationValue === 1 && this.deviceGenerationValue === 1 && deviceGeneration === 0;
     if (deviceGeneration < this.deviceGenerationValue && !rendererInitialGeneration) {
       return err(
-        invalid(
+        invalid3(
           "stale-generation",
           "reconfigure",
           "deviceGeneration does not precede the current device generation",
@@ -3847,7 +5155,7 @@ var ReadonlyDynamicInputPage = class _ReadonlyDynamicInputPage {
   }
   assertLive(operation) {
     return this.released ? err(
-      invalid(
+      invalid3(
         "released",
         operation,
         ERROR_POLICY2.released.expected,
@@ -4586,12 +5894,12 @@ function createDynamicGeometryLifecycle(maxCandidates = 32, maxMeshBytes = 64 *
           { actual: records.size }
         );
       }
-      const invalid2 = validateMesh(input.mesh);
-      if (invalid2 !== void 0)
+      const invalid4 = validateMesh(input.mesh);
+      if (invalid4 !== void 0)
         return failure3(
           "dynamic-geometry-invalid",
           "MeshAsset satisfies the standard geometry contract",
-          invalid2
+          invalid4
         );
       const candidateBytes = meshByteSize(input.mesh);
       if (!Number.isSafeInteger(candidateBytes) || candidateBytes < 0 || meshBytes > maxMeshBytes - candidateBytes) {
@@ -4922,6 +6230,713 @@ function createDynamicGeometryLifecycle(maxCandidates = 32, maxMeshBytes = 64 *
   };
 }
 
-export { BARREL_DISTORTION_FEATURE_IDENTITY, BARREL_DISTORTION_POST_PROCESS_ID, BARREL_DISTORTION_WGSL, BARREL_DISTORTION_WGSL_COORDINATE, CLOUD_DENSITY_COMPUTE_WGSL, CLOUD_HISTORY_FULLSCREEN_WGSL, CLOUD_HISTORY_SURFACE_COUNT, CLOUD_LAYER_DENSITY_BINDINGS, CLOUD_LAYER_DENSITY_CACHE, CLOUD_LAYER_DENSITY_OUTPUT, CLOUD_LAYER_DENSITY_PROGRAM, CLOUD_LAYER_FEATURE_IDENTITY, CLOUD_RGBA16FLOAT_BYTES_PER_TEXEL, CLOUD_VIEW_FULLSCREEN_WGSL, CLOUD_VIEW_PARAMS_BYTES, CloudHistoryStore, DEFAULT_REFLECTION_PROBE_LIMITS, DynamicGeometryError, DynamicInputError, LOD_OCCLUSION_INSPECTION_MAX_BYTES, LOD_OCCLUSION_INSPECTION_SCHEMA, ReadonlyDynamicInputPage, ReflectionProbeProjection, SSR_FORMAT_PROFILE, SSR_FORMAT_STAGES, acceptCloudLayerGeneration, admitPointsLines, admitReflectionProbe, admitSingleLayerMediumSubmission, admitSsrM0, admitSsrSpatial, advanceProbeFilter, applyCloudSolarTransmittance, boxProjectReflectionDirection, buildCloudDensityCache, buildReflectionProbeTable, cloudCapabilitiesFromRhi, cloudTemporalResetReasons, cloudTemporalSignature, commitProbeFilterStep, compositeCloudRadiance, consumeLodOcclusionInspection, createBarrelDistortionRenderFeature, createCloudHistory, createCloudLayerFeature, createCloudShadowProjection, createDynamicGeometryLifecycle, createProbeFilterState, deriveReflectionFallbackProjection, estimateReflectionProbeBytes, evaluateCloudDensity, inspectCloudLayer, inspectCloudLayerResources, inspectLodOcclusion, inspectPointShadow, inspectReflectionFallback, inspectVolumetricFog, integrateCloudCameraPath, integrateCloudInterior, integrateCloudPath, integrateCloudSolarColumn, intersectCloudLayer, probeFilterIsSteady, projectCloudShadowUv, projectSsrDependencies, projectSsrSpatialInspection, reconstructCloudDensityCache, reflectionFallbackCoverage, reflectionFallbackProjectionSignature, reflectionFallbackSourceKey, reflectionProbeTableBytes, reprojectCloudHistory, resolveReflectionFallbackSource, resolveSsrAdmissionGeneration, retainCloudLayerAfterFailure, sameCandidateCredential, sampleCloudDensity, sampleCloudShadow, selectReflectionProbe, serializeLodOcclusionInspection, serializeSsrSpatialInspection, snapshotCloudDensityCache, validateReflectionProbeInput, validateScreenSpaceReflection, zeroSsrAdmissionWork };
-//# sourceMappingURL=chunk-ODZWR6JQ.mjs.map
-//# sourceMappingURL=chunk-ODZWR6JQ.mjs.map
+// src/publication/dependencies.ts
+function publicationDependencies(row) {
+  const handles = /* @__PURE__ */ new Set([row.assetHandle]);
+  for (const material of row.materials) {
+    for (const handle of [
+      material.materialHandle,
+      material.baseColorTexture,
+      material.metallicRoughnessTexture,
+      material.normalTexture,
+      material.emissiveTexture,
+      material.occlusionTexture
+    ]) {
+      if (handle) handles.add(handle);
+    }
+    for (const handle of material.textureHandles?.values() ?? []) handles.add(handle);
+    for (const handle of material.samplerHandles?.values() ?? []) handles.add(handle);
+  }
+  return [...handles];
+}
+function publicationFrameDependencies(frame) {
+  const handles = /* @__PURE__ */ new Set();
+  const add = (handle) => {
+    if (handle) handles.add(handle);
+  };
+  add(frame.skylight?.equirectHandle);
+  add(frame.skybox?.equirectHandle);
+  for (const camera of [...frame.cameras, ...frame.auxiliaryCameras]) add(camera.output?.colorLut);
+  for (const light of frame.lights.spot) {
+    add(light.iesProfileHandle);
+    add(light.cookieHandle);
+    add(light.projectorHandle);
+  }
+  const fogs = frame.volumetricFog === void 0 ? [] : [frame.volumetricFog, ...frame.volumetricFog.additional ?? []];
+  for (const fog of fogs) {
+    add(fog.densityHandle);
+    add(fog.projectorHandle);
+  }
+  return [...handles];
+}
+var atlasMaterialCache = /* @__PURE__ */ new WeakMap();
+var atlasOnlyMaterialCache = /* @__PURE__ */ new WeakMap();
+var streamingCacheByWorld = /* @__PURE__ */ new WeakMap();
+function streamingCache(world) {
+  let cache = streamingCacheByWorld.get(world);
+  if (cache === void 0) {
+    cache = {
+      layers: /* @__PURE__ */ new Map(),
+      chunkEntities: /* @__PURE__ */ new Map(),
+      activeChunks: /* @__PURE__ */ new Map()
+    };
+    streamingCacheByWorld.set(world, cache);
+  }
+  return cache;
+}
+function encodeTilemapLayerValue(layerOrder, chunkIndex, sortScope = "layer") {
+  if (sortScope === "per-cell") return layerOrder << 20 | 0;
+  return layerOrder << 20 | chunkIndex & 1048575 | 0;
+}
+function resolveTilesetMaterial(world, tileset, regionIndex, lookup) {
+  const region = tileset.regions[regionIndex];
+  if (region === void 0) return toShared(0);
+  const atlasIndex = region.atlasIndex ?? 0;
+  const atlasGuid = tileset.atlases[atlasIndex];
+  if (atlasGuid === void 0) return toShared(0);
+  const atlas = resolveTilesetRuntime(world, atlasGuid, lookup);
+  if (!atlas.ok) return toShared(0);
+  const atlasHandle = atlas.value.handle;
+  const atlasId = unwrapHandle(atlasHandle);
+  const cacheKey = `${atlasId}|${regionIndex}`;
+  const cache = atlasMaterialCache.get(world) ?? /* @__PURE__ */ new Map();
+  atlasMaterialCache.set(world, cache);
+  const cached = cache.get(cacheKey);
+  if (cached !== void 0) return cached;
+  const atlasSize = tileset.atlasSizes?.[atlasIndex];
+  const atlasWidth = Math.max(
+    1,
+    atlasSize !== void 0 ? atlasSize.pixelWidth : tileset.columns * tileset.tileWidth
+  );
+  const atlasHeight = Math.max(
+    1,
+    atlasSize !== void 0 ? atlasSize.pixelHeight : tileset.rows * tileset.tileHeight
+  );
+  const halfTexelU = 0.5 / atlasWidth;
+  const halfTexelV = 0.5 / atlasHeight;
+  const u = region.x / atlasWidth + halfTexelU;
+  const v = region.y / atlasHeight + halfTexelV;
+  const w = region.width / atlasWidth - 2 * halfTexelU;
+  const h = region.height / atlasHeight - 2 * halfTexelV;
+  const matPayload = {
+    kind: "material",
+    passes: [
+      {
+        name: "Forward",
+        program: { module: "forgeax::sprite" },
+        renderState: {
+          ...{ blend: SPRITE_PREMULTIPLIED_ALPHA_BLEND },
+          tags: { LightMode: "Forward" },
+          queue: 3e3
+        }
+      }
+    ],
+    values: {
+      colorTint: [1, 1, 1, 1],
+      baseColorTexture: atlasHandle,
+      region: [u, v, w, h],
+      pivotAndSize: [0.5, 0.5, 1, 1],
+      flipY: 1
+    }
+  };
+  const matHandle = world.allocSharedRef(
+    "MaterialAsset",
+    matPayload
+  );
+  cache.set(cacheKey, matHandle);
+  return matHandle;
+}
+function resolveAtlasOnlyMaterial(world, tileset, atlasIndex, lookup) {
+  const atlasGuid = tileset.atlases[atlasIndex];
+  if (atlasGuid === void 0) return toShared(0);
+  const atlas = resolveTilesetRuntime(world, atlasGuid, lookup);
+  if (!atlas.ok) return toShared(0);
+  const atlasHandle = atlas.value.handle;
+  const atlasId = unwrapHandle(atlasHandle);
+  const cacheKey = String(atlasId);
+  const cache = atlasOnlyMaterialCache.get(world) ?? /* @__PURE__ */ new Map();
+  atlasOnlyMaterialCache.set(world, cache);
+  const cached = cache.get(cacheKey);
+  if (cached !== void 0) return cached;
+  const matPayload = {
+    kind: "material",
+    passes: [
+      {
+        name: "Forward",
+        program: { module: "forgeax::sprite" },
+        renderState: {
+          ...{ blend: SPRITE_PREMULTIPLIED_ALPHA_BLEND },
+          tags: { LightMode: "Forward" },
+          queue: 3e3
+        }
+      }
+    ],
+    values: {
+      colorTint: [1, 1, 1, 1],
+      baseColorTexture: atlasHandle,
+      region: [0, 0, 1, 1],
+      pivotAndSize: [0.5, 0.5, 1, 1],
+      flipY: 1
+    }
+  };
+  const matHandle = world.allocSharedRef(
+    "MaterialAsset",
+    matPayload
+  );
+  cache.set(cacheKey, matHandle);
+  return matHandle;
+}
+function computeRegionUv(tileset, region, atlasIndex) {
+  const atlasSize = tileset.atlasSizes?.[atlasIndex];
+  const atlasWidth = Math.max(
+    1,
+    atlasSize !== void 0 ? atlasSize.pixelWidth : tileset.columns * tileset.tileWidth
+  );
+  const atlasHeight = Math.max(
+    1,
+    atlasSize !== void 0 ? atlasSize.pixelHeight : tileset.rows * tileset.tileHeight
+  );
+  const halfTexelU = 0.5 / atlasWidth;
+  const halfTexelV = 0.5 / atlasHeight;
+  return [
+    region.x / atlasWidth + halfTexelU,
+    region.y / atlasHeight + halfTexelV,
+    region.width / atlasWidth - 2 * halfTexelU,
+    region.height / atlasHeight - 2 * halfTexelV
+  ];
+}
+var SQRT1_2 = Math.SQRT1_2;
+function effectivePivotYForTilemapFlip(pivotY, pivotX, flipV, flipDiagonal) {
+  const base = flipDiagonal ? pivotX : pivotY;
+  return flipV ? 1 - base : base;
+}
+function specFor(layerCols, chunkSize, cellIndex, packedTile, materialHandle, entry, atlasIndex) {
+  const cellX = cellIndex % layerCols;
+  const cellY = Math.floor(cellIndex / layerCols);
+  const chunkX = Math.floor(cellX / chunkSize);
+  const chunkY = Math.floor(cellY / chunkSize);
+  const chunksPerRow = Math.max(1, Math.ceil(layerCols / chunkSize));
+  const chunkIndex = chunkY * chunksPerRow + chunkX;
+  const { tileId } = decodeTileBits(packedTile);
+  return {
+    cellX,
+    cellY,
+    tileId,
+    packedTile,
+    materialHandle,
+    chunkIndex,
+    widthCells: entry.widthCells ?? 1,
+    heightCells: entry.heightCells ?? 1,
+    pivotX: entry.pivotX ?? 0.5,
+    pivotY: entry.pivotY ?? 0.5,
+    atlasIndex,
+    regionIndex: entry.regionIndex
+  };
+}
+function computeTileTrs(tilemap, spec, packedTile) {
+  const { flipH, flipV, flipDiagonal } = decodeTileBits(packedTile);
+  const basePivotForX = flipDiagonal ? spec.pivotY : spec.pivotX;
+  const effectivePivotX = flipH ? 1 - basePivotForX : basePivotForX;
+  const effectivePivotY = effectivePivotYForTilemapFlip(
+    spec.pivotY,
+    spec.pivotX,
+    flipV,
+    flipDiagonal
+  );
+  const tileSizeX = tilemap.tileSize[0] ?? 1;
+  const tileSizeY = tilemap.tileSize[1] ?? 1;
+  return {
+    posX: (spec.cellX + effectivePivotX + (0.5 - effectivePivotX) * spec.widthCells) * tileSizeX,
+    posY: (spec.cellY + effectivePivotY + (0.5 - effectivePivotY) * spec.heightCells) * tileSizeY,
+    scaleX: (flipH ? -1 : 1) * spec.widthCells * tileSizeX,
+    scaleY: (flipV ? -1 : 1) * spec.heightCells * tileSizeY,
+    quatZ: flipDiagonal ? SQRT1_2 : 0,
+    quatW: flipDiagonal ? SQRT1_2 : 1
+  };
+}
+function spawnDerivedRenderEntities(world, tilemap, layerEntity, layerOrder, spec, packedTile, sortScope = "layer") {
+  const { posX, posY, scaleX, scaleY, quatZ, quatW } = computeTileTrs(tilemap, spec, packedTile);
+  const layerValue = encodeTilemapLayerValue(layerOrder, spec.chunkIndex, sortScope);
+  return world.spawn(
+    {
+      component: Transform,
+      data: {
+        pos: [posX, posY, 0],
+        quat: [0, 0, quatZ, quatW],
+        scale: [scaleX, scaleY, 1]
+      }
+    },
+    { component: MeshFilter, data: { assetHandle: HANDLE_QUAD } },
+    {
+      component: MeshRenderer,
+      data: {
+        materials: [spec.materialHandle]
+      }
+    },
+    { component: Layer, data: { value: layerValue } },
+    { component: ChildOf, data: { parent: layerEntity } }
+  ).unwrap();
+}
+function spawnSpriteInstancesGroup(world, tilemap, tileset, layerEntity, layerOrder, chunkIndex, atlasIndex, materialHandle, cellSpecs) {
+  if (cellSpecs.length === 0) return void 0;
+  const N = cellSpecs.length;
+  const transforms = new Float32Array(N * 16);
+  const regions = new Float32Array(N * 4);
+  const tmpMat = mat4.create();
+  const tmpT = [0, 0, 0];
+  const tmpR = [0, 0, 0, 1];
+  const tmpS = [1, 1, 1];
+  const chunksPerRow = Math.max(1, Math.ceil(tilemap.cols / tilemap.chunkSize));
+  const chunkX = chunkIndex % chunksPerRow;
+  const chunkY = Math.floor(chunkIndex / chunksPerRow);
+  const chunkScaleX = tilemap.chunkSize * (tilemap.tileSize[0] ?? 1);
+  const chunkScaleY = tilemap.chunkSize * (tilemap.tileSize[1] ?? 1);
+  const chunkCenterX = (chunkX + 0.5) * chunkScaleX;
+  const chunkCenterY = (chunkY + 0.5) * chunkScaleY;
+  const invSX = chunkScaleX > 0 ? 1 / chunkScaleX : 1;
+  const invSY = chunkScaleY > 0 ? 1 / chunkScaleY : 1;
+  for (let i = 0; i < N; i++) {
+    const spec = cellSpecs[i];
+    const { posX, posY, scaleX, scaleY, quatZ, quatW } = computeTileTrs(
+      tilemap,
+      spec,
+      spec.packedTile
+    );
+    tmpT[0] = posX;
+    tmpT[1] = posY;
+    tmpT[2] = 0;
+    tmpR[0] = 0;
+    tmpR[1] = 0;
+    tmpR[2] = quatZ;
+    tmpR[3] = quatW;
+    tmpS[0] = scaleX;
+    tmpS[1] = scaleY;
+    tmpS[2] = 1;
+    mat4.compose(tmpMat, tmpT, tmpR, tmpS);
+    const dst = i * 16;
+    for (let c = 0; c < 4; c++) {
+      const base = c * 4;
+      const w3 = tmpMat[base + 3] ?? 0;
+      transforms[dst + base + 0] = ((tmpMat[base + 0] ?? 0) - chunkCenterX * w3) * invSX;
+      transforms[dst + base + 1] = ((tmpMat[base + 1] ?? 0) - chunkCenterY * w3) * invSY;
+      transforms[dst + base + 2] = tmpMat[base + 2] ?? 0;
+      transforms[dst + base + 3] = w3;
+    }
+    const region = tileset.regions[spec.regionIndex];
+    if (region !== void 0) {
+      const [u, v, w, h] = computeRegionUv(tileset, region, atlasIndex);
+      regions[i * 4 + 0] = u;
+      regions[i * 4 + 1] = v;
+      regions[i * 4 + 2] = w;
+      regions[i * 4 + 3] = h;
+    }
+  }
+  const layerValue = encodeTilemapLayerValue(layerOrder, chunkIndex, "layer");
+  return world.spawn(
+    {
+      component: Transform,
+      data: {
+        pos: [chunkCenterX, chunkCenterY, 0],
+        quat: [0, 0, 0, 1],
+        scale: [chunkScaleX, chunkScaleY, 1]
+      }
+    },
+    { component: MeshFilter, data: { assetHandle: HANDLE_QUAD } },
+    {
+      component: MeshRenderer,
+      data: {
+        materials: [materialHandle]
+      }
+    },
+    { component: SpriteInstances, data: { transforms, regions } },
+    { component: Layer, data: { value: layerValue } },
+    { component: ChildOf, data: { parent: layerEntity } }
+  ).unwrap();
+}
+function bucketTileLayer(world, layerEntity, parentEntity, lookup) {
+  const tilemapRes = world.get(parentEntity, Tilemap);
+  if (!tilemapRes.ok) return void 0;
+  const tilemap = tilemapRes.value;
+  const tilesetPayload = lookup(tilemap.tileset);
+  if (tilesetPayload === void 0 || "code" in tilesetPayload) return void 0;
+  if (tilesetPayload.kind !== "tileset") return void 0;
+  const tileset = tilesetPayload;
+  const layerRes = world.get(layerEntity, TileLayer);
+  if (!layerRes.ok) return void 0;
+  const layer = layerRes.value;
+  const tiles = layer.tiles;
+  const sortScope = decodeSortScope(layer.sortScope);
+  const useSpriteInstances = sortScope === "layer";
+  const specs = [];
+  for (let i = 0; i < tiles.length; i++) {
+    const packed = tiles[i] ?? 0;
+    if (packed === 0) continue;
+    const { tileId } = decodeTileBits(packed);
+    if (tileId === 0) continue;
+    const entry = tileset.tiles[tileId - 1];
+    if (entry === void 0) continue;
+    const region = tileset.regions[entry.regionIndex];
+    if (region === void 0) continue;
+    const atlasIndex = region.atlasIndex ?? 0;
+    const materialHandle = useSpriteInstances ? resolveAtlasOnlyMaterial(world, tileset, atlasIndex, lookup) : resolveTilesetMaterial(world, tileset, entry.regionIndex, lookup);
+    const spec = specFor(
+      tilemap.cols,
+      tilemap.chunkSize,
+      i,
+      packed,
+      materialHandle,
+      entry,
+      atlasIndex
+    );
+    specs.push(spec);
+  }
+  return {
+    tilemap,
+    layerOrder: layer.layerOrder,
+    sortScope,
+    tileset,
+    specs
+  };
+}
+function buildCameraFrustumPlanes(world) {
+  const query = world.query({ with: [Camera, Transform, GlobalTransform] }).unwrap();
+  let result = null;
+  for (const row of query) {
+    const camEntity = row.entity;
+    const camRes = world.get(camEntity, Camera);
+    const trRes = world.get(camEntity, GlobalTransform);
+    if (!camRes.ok || !trRes.ok) continue;
+    const cam = camRes.value;
+    const tr = trRes.value;
+    const { near, far } = cam;
+    if (near >= far) continue;
+    const proj = mat4.create();
+    if (cam.projection === CAMERA_PROJECTION_ORTHOGRAPHIC) {
+      mat4.orthographic(
+        proj,
+        cam.left,
+        cam.right,
+        cam.top,
+        cam.bottom,
+        near,
+        far
+      );
+    } else {
+      mat4.perspective(
+        proj,
+        cam.fov,
+        cam.aspect,
+        near,
+        far
+      );
+    }
+    const view = mat4.create();
+    mat4.invert(
+      view,
+      tr.world
+    );
+    const vp = mat4.create();
+    mat4.multiply(
+      vp,
+      proj,
+      view
+    );
+    const f = frustum.create();
+    frustum.fromViewProjection(f, vp);
+    result = f;
+    break;
+  }
+  return result;
+}
+function computeChunkStreamBounds(tilemap, specs) {
+  let minX = Number.MAX_VALUE;
+  let minY = Number.MAX_VALUE;
+  let maxX = -Number.MAX_VALUE;
+  let maxY = -Number.MAX_VALUE;
+  for (const spec of specs) {
+    const { posX, posY, scaleX, scaleY } = computeTileTrs(tilemap, spec, spec.packedTile);
+    const halfW = Math.abs(scaleX) * 0.5;
+    const halfH = Math.abs(scaleY) * 0.5;
+    const x0 = posX - halfW;
+    const x1 = posX + halfW;
+    const y0 = posY - halfH;
+    const y1 = posY + halfH;
+    if (x0 < minX) minX = x0;
+    if (y0 < minY) minY = y0;
+    if (x1 > maxX) maxX = x1;
+    if (y1 > maxY) maxY = y1;
+  }
+  return [minX, minY, -1, maxX, maxY, 1];
+}
+function purgeDerivedEntities(world, layerEntity) {
+  const r = world.get(layerEntity, Children);
+  if (!r.ok) return;
+  const snap = r.value.entities;
+  for (let i = 0; i < snap.length; i++) {
+    const e = snap[i];
+    if (e !== void 0) world.despawn(e);
+  }
+}
+function evictDeadPerCellStreamingCaches(work, world) {
+  const cache = streamingCache(world);
+  const aliveLayerKeys = /* @__PURE__ */ new Set();
+  for (const w of work) {
+    aliveLayerKeys.add(String(w.layerEntity));
+  }
+  const deadLayerKeys = /* @__PURE__ */ new Set();
+  for (const layerKey of cache.activeChunks.keys()) {
+    if (!aliveLayerKeys.has(layerKey)) deadLayerKeys.add(layerKey);
+  }
+  for (const layerKey of cache.layers.keys()) {
+    if (!aliveLayerKeys.has(layerKey)) deadLayerKeys.add(layerKey);
+  }
+  for (const deadKey of deadLayerKeys) {
+    const activeSet = cache.activeChunks.get(deadKey);
+    if (activeSet !== void 0) {
+      for (const chunkIdx of activeSet) {
+        cache.chunkEntities.delete(`${deadKey}:${chunkIdx}`);
+      }
+      cache.activeChunks.delete(deadKey);
+    }
+    cache.layers.delete(deadKey);
+  }
+}
+function tilemapChunkExtractSystem(world, lookup = () => void 0) {
+  const streaming = streamingCache(world);
+  const work = [];
+  const tileLayerQuery = world.query({ read: [TileLayer, ChildOf] }).unwrap();
+  for (const row of tileLayerQuery) {
+    const layer = row.get(TileLayer);
+    const parent = row.get(ChildOf).parent;
+    if (parent === null) continue;
+    work.push({
+      layerEntity: row.entity,
+      parentEntity: parent,
+      dirty: layer.dirty,
+      sortScopeRaw: layer.sortScope
+    });
+  }
+  evictDeadPerCellStreamingCaches(work, world);
+  let frustumPlanes;
+  for (const w of work) {
+    const layerKey = String(w.layerEntity);
+    const isStreaming = decodeSortScope(w.sortScopeRaw) === "per-cell";
+    if (!isStreaming) {
+      const childrenRes = world.get(w.layerEntity, Children);
+      const childCount = childrenRes.ok ? childrenRes.value.entities.length : 0;
+      if (childCount > 0 && w.dirty === 0) continue;
+      purgeDerivedEntities(world, w.layerEntity);
+      const bucket = bucketTileLayer(world, w.layerEntity, w.parentEntity, lookup);
+      if (bucket === void 0) continue;
+      const byChunkAtlas = /* @__PURE__ */ new Map();
+      for (const spec of bucket.specs) {
+        const key = (spec.chunkIndex & 1048575) << 16 | spec.atlasIndex & 65535;
+        const list = byChunkAtlas.get(key);
+        if (list === void 0) {
+          byChunkAtlas.set(key, [spec]);
+        } else {
+          list.push(spec);
+        }
+      }
+      for (const groupSpecs of byChunkAtlas.values()) {
+        const first = groupSpecs[0];
+        if (first === void 0) continue;
+        spawnSpriteInstancesGroup(
+          world,
+          bucket.tilemap,
+          bucket.tileset,
+          w.layerEntity,
+          bucket.layerOrder,
+          first.chunkIndex,
+          first.atlasIndex,
+          first.materialHandle,
+          groupSpecs
+        );
+      }
+      if (w.dirty !== 0) {
+        world.set(w.layerEntity, TileLayer, { dirty: 0 }).unwrap();
+      }
+      continue;
+    }
+    if (w.dirty !== 0 || !streaming.layers.has(layerKey)) {
+      const activeSet2 = streaming.activeChunks.get(layerKey);
+      if (activeSet2 !== void 0) {
+        for (const chunkIdx of activeSet2) {
+          const key = `${layerKey}:${chunkIdx}`;
+          const entities = streaming.chunkEntities.get(key);
+          if (entities !== void 0) {
+            for (const e of entities) world.despawn(e);
+            streaming.chunkEntities.delete(key);
+          }
+        }
+        activeSet2.clear();
+      }
+      streaming.layers.delete(layerKey);
+      const bucket = bucketTileLayer(world, w.layerEntity, w.parentEntity, lookup);
+      if (bucket !== void 0) {
+        const byChunkSpecs = /* @__PURE__ */ new Map();
+        for (const spec of bucket.specs) {
+          const list = byChunkSpecs.get(spec.chunkIndex);
+          if (list === void 0) {
+            byChunkSpecs.set(spec.chunkIndex, [spec]);
+          } else {
+            list.push(spec);
+          }
+        }
+        const byChunk = /* @__PURE__ */ new Map();
+        for (const [chunkIdx, specs] of byChunkSpecs) {
+          byChunk.set(chunkIdx, {
+            specs,
+            bounds: computeChunkStreamBounds(bucket.tilemap, specs)
+          });
+        }
+        streaming.layers.set(layerKey, {
+          byChunk,
+          tilemap: bucket.tilemap,
+          layerOrder: bucket.layerOrder,
+          sortScope: bucket.sortScope
+        });
+      }
+      if (w.dirty !== 0) {
+        world.set(w.layerEntity, TileLayer, { dirty: 0 }).unwrap();
+      }
+    }
+    const cache = streaming.layers.get(layerKey);
+    if (cache === void 0) continue;
+    if (frustumPlanes === void 0) {
+      frustumPlanes = buildCameraFrustumPlanes(world);
+    }
+    const activeSet = streaming.activeChunks.get(layerKey) ?? /* @__PURE__ */ new Set();
+    streaming.activeChunks.set(layerKey, activeSet);
+    const { tilemap } = cache;
+    for (const [chunkIdx, entry] of cache.byChunk) {
+      const { specs, bounds } = entry;
+      const visible = frustumPlanes === null || frustum.intersectsBox(frustumPlanes, bounds);
+      const wasActive = activeSet.has(chunkIdx);
+      if (visible && !wasActive) {
+        const spawned = [];
+        for (const spec of specs) {
+          const e = spawnDerivedRenderEntities(
+            world,
+            tilemap,
+            w.layerEntity,
+            cache.layerOrder,
+            spec,
+            spec.packedTile,
+            cache.sortScope
+          );
+          spawned.push(e);
+        }
+        streaming.chunkEntities.set(`${layerKey}:${chunkIdx}`, spawned);
+        activeSet.add(chunkIdx);
+      } else if (!visible && wasActive) {
+        const key = `${layerKey}:${chunkIdx}`;
+        const entities = streaming.chunkEntities.get(key);
+        if (entities !== void 0) {
+          for (const e of entities) world.despawn(e);
+          streaming.chunkEntities.delete(key);
+        }
+        activeSet.delete(chunkIdx);
+      }
+    }
+  }
+}
+
+// src/scene/source-systems.ts
+var nextId = 0;
+function registerRenderSourceSystems(world, assets, meshes) {
+  const releaseTransforms = registerPropagateTransforms(world);
+  const name = `renderDerived:${++nextId}`;
+  const result = world.addSystem(Update, {
+    name,
+    queries: [],
+    fn: (world2) => {
+      tilemapChunkExtractSystem(world2, (guid) => assets.lookup(guid));
+      glyphTextLayoutSystem(world2, meshes).unwrap();
+    }
+  });
+  if (!result.ok) {
+    releaseTransforms();
+    throw result.error;
+  }
+  return () => {
+    world.removeSystem(Update, name).unwrap();
+    releaseTransforms();
+  };
+}
+
+// src/extract/material-context.ts
+function renderMaterialContext(caps) {
+  if (caps.backendKind === "null") return {};
+  return {
+    materialContext: {
+      backend: caps.backendKind === "wgpu-webgl2" ? "webgl2" : caps.backendKind,
+      capability: caps.storageBuffer ? "storage-buffer" : "uniform-fallback",
+      pipeline: "forward",
+      geometry: "mesh",
+      pass: "forward",
+      profile: "forgeax-material-wgsl-v1",
+      toolchain: "naga-oil",
+      instrumentation: "none"
+    }
+  };
+}
+var RENDERABLE_SOURCE_COMPONENTS = [
+  ChildOf,
+  MeshFilter,
+  MeshRenderer,
+  Instances,
+  SpriteInstances,
+  SpriteRegionOverride,
+  Skin,
+  Layer,
+  Visibility,
+  MorphWeights,
+  Points,
+  Lines,
+  SortKey
+];
+function createGlobalTransformChangeQuery(world) {
+  const result = world.query({ read: [GlobalTransform], changed: [GlobalTransform] });
+  if (!result.ok) throw result.error;
+  const query = result.value;
+  for (const _span of query.spans().unwrap()) {
+  }
+  return query;
+}
+function createRenderSourceState(world, additional = []) {
+  const components = [
+    ...RENDERABLE_SOURCE_COMPONENTS,
+    RuntimeMaterialValue,
+    RuntimeMeshVertices,
+    ...additional
+  ];
+  const projection = createStateProjection(world, components, [
+    ...components,
+    Transform,
+    GlobalTransform
+  ]);
+  const entities = /* @__PURE__ */ new Map();
+  const contentHandles = /* @__PURE__ */ new Map();
+  const batch = projection.read();
+  for (const index of batch.indices) {
+    const entity = projection.entity(index);
+    if (entity !== void 0) {
+      entities.set(index, entity);
+      const handles = [];
+      const material = world.hasComponent(entity, RuntimeMaterialValue) ? world.get(entity, RuntimeMaterialValue) : void 0;
+      const mesh = world.hasComponent(entity, RuntimeMeshVertices) ? world.get(entity, RuntimeMeshVertices) : void 0;
+      if (material?.ok) handles.push(Number(material.value.asset));
+      if (mesh?.ok) handles.push(Number(mesh.value.asset));
+      if (handles.length > 0) contentHandles.set(index, handles);
+    }
+  }
+  return { projection, entities, contentHandles, batch };
+}
+function isRenderableMember(world, entity) {
+  return world.hasComponent(entity, MeshRenderer) && world.hasComponent(entity, Transform) && world.hasComponent(entity, MeshFilter);
+}
+
+export { BARREL_DISTORTION_FEATURE_IDENTITY, BARREL_DISTORTION_POST_PROCESS_ID, BARREL_DISTORTION_WGSL, BARREL_DISTORTION_WGSL_COORDINATE, CLOUD_DENSITY_COMPUTE_WGSL, CLOUD_HISTORY_FULLSCREEN_WGSL, CLOUD_HISTORY_SURFACE_COUNT, CLOUD_LAYER_DENSITY_BINDINGS, CLOUD_LAYER_DENSITY_CACHE, CLOUD_LAYER_DENSITY_OUTPUT, CLOUD_LAYER_DENSITY_PROGRAM, CLOUD_LAYER_FEATURE_IDENTITY, CLOUD_RGBA16FLOAT_BYTES_PER_TEXEL, CLOUD_VIEW_FULLSCREEN_WGSL, CLOUD_VIEW_PARAMS_BYTES, CloudHistoryStore, DEFAULT_REFLECTION_PROBE_LIMITS, DynamicGeometryError, DynamicInputError, LOD_OCCLUSION_INSPECTION_MAX_BYTES, LOD_OCCLUSION_INSPECTION_SCHEMA, RENDERABLE_SOURCE_COMPONENTS, ReadonlyDynamicInputPage, ReflectionProbeProjection, RenderPublicationError, RenderPublicationTargetOwner, RenderPublicationTargetReceiver, SSR_FORMAT_PROFILE, SSR_FORMAT_STAGES, acceptCloudLayerGeneration, acquireSwapChainTarget, admitPointsLines, admitReflectionProbe, admitSingleLayerMediumSubmission, admitSsrM0, admitSsrSpatial, advanceProbeFilter, applyCloudSolarTransmittance, boxProjectReflectionDirection, buildCloudDensityCache, buildReflectionProbeTable, cloudCapabilitiesFromRhi, cloudTemporalResetReasons, cloudTemporalSignature, commitProbeFilterStep, compositeCloudRadiance, consumeLodOcclusionInspection, createBarrelDistortionRenderFeature, createCloudHistory, createCloudLayerFeature, createCloudShadowProjection, createDynamicGeometryLifecycle, createGlobalTransformChangeQuery, createProbeFilterState, createRenderSourceState, createRenderTargetHost, deriveReflectionFallbackProjection, estimateReflectionProbeBytes, evaluateCloudDensity, graphExecutionPhase, inspectCloudLayer, inspectCloudLayerResources, inspectLodOcclusion, inspectPointShadow, inspectReflectionFallback, inspectVolumetricFog, integrateCloudCameraPath, integrateCloudInterior, integrateCloudPath, integrateCloudSolarColumn, intersectCloudLayer, isRenderableMember, probeFilterIsSteady, projectCloudShadowUv, projectSsrDependencies, projectSsrSpatialInspection, publicationDependencies, publicationFrameDependencies, publicationTargetSources, reconstructCloudDensityCache, reflectionFallbackCoverage, reflectionFallbackProjectionSignature, reflectionFallbackSourceKey, reflectionProbeTableBytes, registerRenderSourceSystems, renderMaterialContext, renderPublicationTransfers, reprojectCloudHistory, resolveDirectionalShadowAtlasGrid, resolveReflectionFallbackSource, resolveShadowMapSize, resolveSpotShadowMapSize, resolveSsrAdmissionGeneration, retainCloudLayerAfterFailure, sameCandidateCredential, sampleCloudDensity, sampleCloudShadow, selectReflectionProbe, serializeLodOcclusionInspection, serializeSsrSpatialInspection, snapshotCloudDensityCache, validateReflectionProbeInput, validateScreenSpaceReflection, zeroSsrAdmissionWork };
+//# sourceMappingURL=chunk-MZ4C7EHF.mjs.map
+//# sourceMappingURL=chunk-MZ4C7EHF.mjs.map