@game_engine/runtime-browser-pixi 0.1.0-alpha.1

package/dist/index.js

@@ -0,0 +1,1130 @@
+// src/index.ts
+var defaultMarkerSize = 4;
+var defaultRectangleFill = 3900150;
+var defaultMarkerFill = 16096779;
+var defaultStroke = 1120295;
+var defaultStrokeWidth = 1;
+var defaultAlpha = 0.35;
+var defaultLayer = "debug";
+var supportedManifestAssetTypes = /* @__PURE__ */ new Set(["texture", "sprite", "atlas", "audio", "font"]);
+function createDisplayList(snapshot, options = {}) {
+  const diagnostics = [];
+  const animationClips = collectAnimationClips(snapshot);
+  const assetsById = collectDisplayAssets(options.assets);
+  const items = [...snapshot.entities ?? []].sort((left, right) => left.id.localeCompare(right.id)).flatMap((entity) => {
+    const transform = readTransform(entity.components?.Transform);
+    if (!transform) {
+      if (isRenderMetadataOnly(entity.components)) {
+        return [];
+      }
+      diagnostics.push({
+        severity: "warning",
+        code: "PIXI_ENTITY_MISSING_TRANSFORM",
+        entityId: entity.id,
+        path: `$.entities[${JSON.stringify(entity.id)}].components.Transform`,
+        message: `Entity '${entity.id}' was skipped because it has no valid Transform component.`,
+        suggestion: "Add a Transform component before expecting the browser renderer to project this entity."
+      });
+      return [];
+    }
+    const collider = readCollider(entity.components?.Collider);
+    const animation = readAnimatorPlayback(
+      entity.id,
+      entity.components?.Animator,
+      animationClips,
+      assetsById,
+      diagnostics
+    );
+    if (collider) {
+      return [
+        createDisplayItem(entity.id, "rectangle", transform, collider.size[0], collider.size[1], {
+          fill: options.rectangleFill ?? defaultRectangleFill,
+          options,
+          animation
+        })
+      ];
+    }
+    if (options.drawTransformOnlyMarkers ?? true) {
+      const markerSize = options.markerSize ?? defaultMarkerSize;
+      return [
+        createDisplayItem(entity.id, "marker", transform, markerSize, markerSize, {
+          fill: options.markerFill ?? defaultMarkerFill,
+          options,
+          animation
+        })
+      ];
+    }
+    return [];
+  }).map((item, index) => ({
+    ...item,
+    order: index
+  }));
+  return {
+    version: 1,
+    frame: snapshot.frame,
+    items,
+    diagnostics
+  };
+}
+function createPixiTextureResolverFromManifest(manifest, textures = {}) {
+  const diagnostics = [];
+  const document = readManifestDocument(manifest, diagnostics);
+  if (!document) {
+    return {
+      assets: [],
+      textureResolver: () => void 0,
+      diagnostics
+    };
+  }
+  const assets = readManifestAssets(document.assets, diagnostics);
+  const spriteAssetIds = new Set(assets.filter((asset) => asset.type === "sprite").map((asset) => asset.id));
+  return {
+    assets,
+    textureResolver: (request) => {
+      if (!spriteAssetIds.has(request.assetId)) {
+        return void 0;
+      }
+      return resolveTextureByAssetId(textures, request);
+    },
+    diagnostics
+  };
+}
+async function createPixiAssetLoaderFromManifest(manifestOrAssets, options = {}) {
+  const manifestDiagnostics = [];
+  const assets = readManifestOrAssetDefinitions(manifestOrAssets, manifestDiagnostics);
+  const diagnostics = [...manifestDiagnostics];
+  const assetsById = new Map(assets.map((asset) => [asset.id, asset]));
+  const textures = /* @__PURE__ */ new Map();
+  const loadTexture = options.loadTexture ?? loadPixiTextureFromUrl;
+  for (const asset of assets) {
+    if (asset.type !== "sprite") {
+      continue;
+    }
+    const atlasFrame = resolveDisplayAtlasFrameReference(asset, assetsById);
+    const url = resolveAssetLoadUrl(asset, atlasFrame, options, diagnostics);
+    if (!url) {
+      continue;
+    }
+    let texture;
+    try {
+      texture = await loadTexture({
+        asset,
+        ...atlasFrame ? { atlasFrame } : {},
+        url
+      });
+    } catch (error) {
+      diagnostics.push({
+        severity: "warning",
+        code: "PIXI_ASSET_TEXTURE_LOAD_FAILED",
+        path: `$.assets[${JSON.stringify(asset.id)}].path`,
+        message: `Sprite asset '${asset.id}' failed to load texture from '${url}'.`,
+        suggestion: error instanceof Error ? error.message : "Check the browser asset URL, server routing, and caller-provided texture loader."
+      });
+      continue;
+    }
+    if (!texture) {
+      diagnostics.push({
+        severity: "warning",
+        code: "PIXI_ASSET_TEXTURE_LOAD_MISSING",
+        path: `$.assets[${JSON.stringify(asset.id)}].path`,
+        message: `Sprite asset '${asset.id}' did not produce a Pixi texture from '${url}'.`,
+        suggestion: "Return a Pixi texture from loadTexture or leave the renderer debug fallback in place."
+      });
+      continue;
+    }
+    textures.set(asset.id, texture);
+  }
+  const spriteAssetIds = new Set(assets.filter((asset) => asset.type === "sprite").map((asset) => asset.id));
+  return {
+    assets,
+    textureResolver: (request) => {
+      if (!spriteAssetIds.has(request.assetId)) {
+        return void 0;
+      }
+      return textures.get(request.assetId);
+    },
+    diagnostics,
+    loadedTextureIds: [...textures.keys()].sort((left, right) => left.localeCompare(right))
+  };
+}
+async function createPixiAtlasTextureResolverFromManifest(manifestOrAssets, options = {}) {
+  const manifestDiagnostics = [];
+  const assets = readManifestOrAssetDefinitions(manifestOrAssets, manifestDiagnostics);
+  const diagnostics = [...manifestDiagnostics];
+  const assetsById = new Map(assets.map((asset) => [asset.id, asset]));
+  const textures = /* @__PURE__ */ new Map();
+  const frameTextures = /* @__PURE__ */ new Map();
+  const sliceTexture = options.sliceTexture ?? slicePixiTextureByAtlasFrame;
+  const diagnosedAtlasTextureIds = /* @__PURE__ */ new Set();
+  for (const asset of assets) {
+    if (asset.type !== "sprite" || !asset.atlas || !asset.frame) {
+      continue;
+    }
+    const atlas = assetsById.get(asset.atlas);
+    const atlasFrame = resolveDisplayAtlasFrameReference(asset, assetsById);
+    if (atlas?.type !== "atlas" || !atlasFrame) {
+      diagnostics.push({
+        severity: "warning",
+        code: "PIXI_ATLAS_SLICE_FRAME_UNRESOLVED",
+        path: `$.assets[${JSON.stringify(asset.id)}].frame`,
+        message: `Sprite asset '${asset.id}' cannot resolve atlas frame '${asset.frame}' in atlas '${asset.atlas}'.`,
+        suggestion: "Run project validation and ensure SpriteAsset.atlas and SpriteAsset.frame still match atlas metadata."
+      });
+      continue;
+    }
+    const atlasTexture = resolveAtlasTexture(atlas, assetsById, options.atlasTextures);
+    if (!atlasTexture) {
+      const diagnosticKey = atlas.texture ?? atlas.id;
+      if (!diagnosedAtlasTextureIds.has(diagnosticKey)) {
+        diagnosedAtlasTextureIds.add(diagnosticKey);
+        diagnostics.push(createMissingAtlasTextureDiagnostic(atlas));
+      }
+      continue;
+    }
+    if (!isAtlasFrameInsideTexture(atlasFrame.rect, atlasTexture)) {
+      diagnostics.push({
+        severity: "warning",
+        code: "PIXI_ATLAS_SLICE_RECT_OUT_OF_BOUNDS",
+        path: `$.assets[${JSON.stringify(asset.id)}].frame`,
+        message: `Sprite asset '${asset.id}' frame '${atlasFrame.frame}' is outside atlas texture '${atlas.id}'.`,
+        suggestion: "Check atlas frame rects against the loaded source texture dimensions before slicing. Scene validation remains metadata-only."
+      });
+      continue;
+    }
+    let slicedTexture;
+    try {
+      slicedTexture = await sliceTexture({
+        sprite: asset,
+        atlas,
+        atlasFrame,
+        atlasTexture
+      });
+    } catch (error) {
+      diagnostics.push({
+        severity: "warning",
+        code: "PIXI_ATLAS_SLICE_FAILED",
+        path: `$.assets[${JSON.stringify(asset.id)}].frame`,
+        message: `Sprite asset '${asset.id}' failed to slice frame '${atlasFrame.frame}' from atlas '${atlas.id}'.`,
+        suggestion: error instanceof Error ? error.message : "Check the loaded atlas texture, frame rect, and caller-provided sliceTexture function."
+      });
+      continue;
+    }
+    if (!slicedTexture) {
+      diagnostics.push({
+        severity: "warning",
+        code: "PIXI_ATLAS_SLICE_MISSING",
+        path: `$.assets[${JSON.stringify(asset.id)}].frame`,
+        message: `Sprite asset '${asset.id}' did not produce a sliced texture for frame '${atlasFrame.frame}'.`,
+        suggestion: "Return a Pixi texture from sliceTexture or leave the renderer debug fallback in place."
+      });
+      continue;
+    }
+    textures.set(asset.id, slicedTexture);
+    if (!frameTextures.has(atlasFrame.frame)) {
+      frameTextures.set(atlasFrame.frame, slicedTexture);
+    }
+  }
+  return {
+    assets,
+    textureResolver: (request) => {
+      const slicedTexture = textures.get(request.assetId) ?? (request.atlasFrame ? frameTextures.get(request.atlasFrame.frame) : void 0);
+      if (slicedTexture) {
+        return slicedTexture;
+      }
+      return options.fallbackTextureResolver ? resolveTextureByAssetId(options.fallbackTextureResolver, request) : void 0;
+    },
+    diagnostics,
+    slicedTextureIds: [...textures.keys()].sort((left, right) => left.localeCompare(right)),
+    slicedFrameIds: [...frameTextures.keys()].sort((left, right) => left.localeCompare(right))
+  };
+}
+async function createPixiRenderer(options = {}) {
+  const pixi = await import("pixi.js");
+  const app = new pixi.Application();
+  await app.init({
+    width: options.width ?? 800,
+    height: options.height ?? 450,
+    backgroundColor: options.backgroundColor ?? 988970,
+    resolution: options.resolution ?? 1,
+    antialias: options.antialias ?? false,
+    preference: options.preference ?? "webgl",
+    preserveDrawingBuffer: options.preserveDrawingBuffer ?? false
+  });
+  if (options.container) {
+    options.container.appendChild(app.canvas);
+  }
+  return {
+    app,
+    stage: app.stage,
+    async renderSnapshot(snapshot, renderOptions) {
+      return renderWorldSnapshot(snapshot, {
+        ...renderOptions,
+        app,
+        stage: app.stage
+      });
+    },
+    destroy() {
+      app.destroy(true);
+    }
+  };
+}
+async function renderWorldSnapshot(snapshot, options = {}) {
+  const renderer = options.renderer;
+  const app = options.app ?? renderer?.app;
+  const stage = options.stage ?? renderer?.stage ?? app?.stage;
+  if (!stage) {
+    throw new Error("renderWorldSnapshot requires a Pixi renderer, app, or stage.");
+  }
+  const pixi = await import("pixi.js");
+  const displayList = createDisplayList(snapshot, options);
+  if (options.clear ?? true) {
+    stage.removeChildren();
+  }
+  for (const item of displayList.items) {
+    const texture = resolveTextureForDisplayItem(item, options.textureResolver);
+    if (texture) {
+      const sprite = new pixi.Sprite(texture);
+      markAnimationTextureState(item, true);
+      drawTexturedDisplayItem(sprite, item);
+      stage.addChild(sprite);
+    } else {
+      const graphic = new pixi.Graphics();
+      markAnimationTextureState(item, false);
+      drawDisplayItem(graphic, item);
+      stage.addChild(graphic);
+    }
+  }
+  app?.renderer.render(stage);
+  return displayList;
+}
+async function renderWorld(world, options = {}) {
+  return renderWorldSnapshot(worldToSnapshot(world, options), options);
+}
+function createDisplayItem(id, kind, transform, width, height, config) {
+  return {
+    id,
+    kind,
+    x: transform.position[0],
+    y: transform.position[1],
+    width,
+    height,
+    rotation: transform.rotation,
+    scaleX: transform.scale[0],
+    scaleY: transform.scale[1],
+    fill: config.fill,
+    alpha: config.options.alpha ?? defaultAlpha,
+    stroke: config.options.stroke ?? defaultStroke,
+    strokeWidth: config.options.strokeWidth ?? defaultStrokeWidth,
+    layer: config.options.layer ?? defaultLayer,
+    order: 0,
+    ...config.animation ? { animation: config.animation } : {}
+  };
+}
+function drawDisplayItem(graphic, item) {
+  graphic.position.set(item.x, item.y);
+  graphic.rotation = item.rotation;
+  graphic.scale.set(item.scaleX, item.scaleY);
+  if (item.kind === "rectangle") {
+    graphic.rect(item.width / -2, item.height / -2, item.width, item.height);
+  } else {
+    graphic.rect(item.width / -2, item.height / -2, item.width, item.height);
+  }
+  graphic.fill({ color: item.fill, alpha: item.alpha });
+  graphic.stroke({ color: item.stroke, width: item.strokeWidth });
+}
+function drawTexturedDisplayItem(sprite, item) {
+  sprite.anchor.set(0.5);
+  sprite.position.set(item.x, item.y);
+  sprite.rotation = item.rotation;
+  sprite.width = item.width * item.scaleX;
+  sprite.height = item.height * item.scaleY;
+}
+function resolveTextureForDisplayItem(item, resolver) {
+  const asset = item.animation?.asset;
+  if (!asset || !resolver) {
+    return void 0;
+  }
+  if (typeof resolver === "function") {
+    return resolver({
+      assetId: asset.id,
+      asset,
+      ...asset.atlasFrame ? { atlasFrame: asset.atlasFrame } : {},
+      item
+    });
+  }
+  if (resolver instanceof Map) {
+    return resolver.get(asset.id);
+  }
+  return resolver[asset.id];
+}
+function resolveTextureByAssetId(resolver, request) {
+  if (typeof resolver === "function") {
+    return resolver(request);
+  }
+  if (resolver instanceof Map) {
+    return resolver.get(request.assetId);
+  }
+  return resolver[request.assetId];
+}
+async function loadPixiTextureFromUrl(request) {
+  const pixi = await import("pixi.js");
+  return await pixi.Assets.load(request.url);
+}
+async function slicePixiTextureByAtlasFrame(request) {
+  const pixi = await import("pixi.js");
+  const [x, y, width, height] = request.atlasFrame.rect;
+  return new pixi.Texture({
+    source: request.atlasTexture.source,
+    frame: new pixi.Rectangle(x, y, width, height)
+  });
+}
+function resolveAtlasTexture(atlas, assetsById, resolver) {
+  if (!resolver) {
+    return void 0;
+  }
+  const textureAsset = atlas.texture ? assetsById.get(atlas.texture) : void 0;
+  const request = {
+    atlas,
+    ...textureAsset?.type === "texture" ? { textureAsset } : {},
+    ...atlas.texture ? { textureId: atlas.texture } : {}
+  };
+  if (typeof resolver === "function") {
+    return resolver(request);
+  }
+  return resolveTextureByAtlasTextureId(resolver, atlas.texture) ?? resolveTextureByAtlasTextureId(resolver, atlas.id);
+}
+function resolveTextureByAtlasTextureId(resolver, textureId) {
+  if (!textureId) {
+    return void 0;
+  }
+  if (resolver instanceof Map) {
+    return resolver.get(textureId);
+  }
+  return resolver[textureId];
+}
+function createMissingAtlasTextureDiagnostic(atlas) {
+  if (!atlas.texture) {
+    return {
+      severity: "warning",
+      code: "PIXI_ATLAS_SLICE_TEXTURE_REFERENCE_MISSING",
+      path: `$.assets[${JSON.stringify(atlas.id)}].texture`,
+      message: `Atlas asset '${atlas.id}' has no source texture id for slicing.`,
+      suggestion: "Set atlas.texture to a texture asset id or pass an atlas texture keyed by the atlas id."
+    };
+  }
+  return {
+    severity: "warning",
+    code: "PIXI_ATLAS_SLICE_TEXTURE_MISSING",
+    path: `$.assets[${JSON.stringify(atlas.id)}].texture`,
+    message: `Atlas asset '${atlas.id}' source texture '${atlas.texture}' was not provided to the Pixi atlas slicing helper.`,
+    suggestion: "Pass atlasTextures keyed by atlas.texture or atlas id, or keep debug fallback behavior."
+  };
+}
+function isAtlasFrameInsideTexture(rect, texture) {
+  const [x, y, width, height] = rect;
+  return x >= 0 && y >= 0 && x + width <= texture.width && y + height <= texture.height;
+}
+function resolveAssetLoadUrl(asset, atlasFrame, options, diagnostics) {
+  if (options.resolveUrl) {
+    let resolved;
+    try {
+      resolved = options.resolveUrl({
+        asset,
+        ...atlasFrame ? { atlasFrame } : {}
+      });
+    } catch (error) {
+      diagnostics.push({
+        severity: "warning",
+        code: "PIXI_ASSET_TEXTURE_URL_FAILED",
+        path: `$.assets[${JSON.stringify(asset.id)}].path`,
+        message: `Sprite asset '${asset.id}' texture URL resolution failed.`,
+        suggestion: error instanceof Error ? error.message : "Check the caller-provided resolveUrl function and keep asset URL policy explicit."
+      });
+      return void 0;
+    }
+    const url = stringifyAssetUrl(resolved);
+    if (url) {
+      return url;
+    }
+    diagnostics.push({
+      severity: "warning",
+      code: "PIXI_ASSET_TEXTURE_URL_UNRESOLVED",
+      path: `$.assets[${JSON.stringify(asset.id)}].path`,
+      message: `Sprite asset '${asset.id}' has no browser texture URL.`,
+      suggestion: "Return a URL from resolveUrl or omit the texture so the renderer uses the debug fallback."
+    });
+    return void 0;
+  }
+  if (options.baseUrl !== void 0) {
+    try {
+      return new URL(asset.path, options.baseUrl).toString();
+    } catch (error) {
+      diagnostics.push({
+        severity: "warning",
+        code: "PIXI_ASSET_TEXTURE_URL_FAILED",
+        path: `$.assets[${JSON.stringify(asset.id)}].path`,
+        message: `Sprite asset '${asset.id}' path '${asset.path}' could not be resolved against the loader baseUrl.`,
+        suggestion: error instanceof Error ? error.message : "Pass an absolute baseUrl or a resolveUrl function for browser asset paths."
+      });
+      return void 0;
+    }
+  }
+  return asset.path;
+}
+function stringifyAssetUrl(value) {
+  if (value instanceof URL) {
+    return value.toString();
+  }
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function markAnimationTextureState(item, applied) {
+  const assetId = item.animation?.asset?.id;
+  if (!assetId || !item.animation) {
+    return;
+  }
+  item.animation.texture = {
+    assetId,
+    applied,
+    mode: applied ? "texture" : "debug"
+  };
+}
+function worldToSnapshot(world, options) {
+  const fixedDeltaSeconds = options.fixedDeltaSeconds ?? 1 / 60;
+  const frame = options.frame ?? 0;
+  return {
+    version: 1,
+    frame,
+    fixedDeltaSeconds,
+    elapsedSeconds: options.elapsedSeconds ?? roundDeterministic(frame * fixedDeltaSeconds),
+    entities: world.listEntities().map((entity) => ({
+      id: entity.id,
+      components: entity.components
+    })).sort((left, right) => left.id.localeCompare(right.id))
+  };
+}
+function collectAnimationClips(snapshot) {
+  const clips = /* @__PURE__ */ new Map();
+  for (const entity of snapshot.entities ?? []) {
+    const clip = readAnimationClip(entity.components?.AnimationClip);
+    if (clip) {
+      clips.set(clip.id, clip);
+    }
+  }
+  return clips;
+}
+function readAnimationClip(value) {
+  if (!isRecord(value) || typeof value.id !== "string" || !Array.isArray(value.frames)) {
+    return void 0;
+  }
+  const frames = value.frames.flatMap((frame) => {
+    if (!isRecord(frame) || typeof frame.id !== "string") {
+      return [];
+    }
+    const sprite = typeof frame.sprite === "string" ? frame.sprite : void 0;
+    const rect = readNumberTuple(frame.rect, 4);
+    return [
+      {
+        id: frame.id,
+        ...sprite ? { sprite } : {},
+        ...rect ? { rect } : {}
+      }
+    ];
+  });
+  if (frames.length === 0) {
+    return void 0;
+  }
+  return {
+    id: value.id,
+    ...Array.isArray(value.frameOrder) ? { frameOrder: value.frameOrder.filter((frameId) => typeof frameId === "string") } : {},
+    frames
+  };
+}
+function readAnimatorPlayback(entityId, value, clips, assetsById, diagnostics) {
+  if (!isRecord(value)) {
+    return void 0;
+  }
+  const activeClip = readString(value.activeClip) ?? readString(value.defaultClip) ?? readString(value.currentClip);
+  if (!activeClip) {
+    return void 0;
+  }
+  const clip = clips.get(activeClip);
+  if (!clip) {
+    diagnostics.push({
+      severity: "warning",
+      code: "PIXI_ANIMATION_CLIP_UNRESOLVED",
+      entityId,
+      path: `$.entities[${JSON.stringify(entityId)}].components.Animator.activeClip`,
+      message: `Animator activeClip '${activeClip}' cannot be resolved by the Pixi display list.`,
+      suggestion: "Run scene validation and ensure the active clip id exists in the rendered snapshot."
+    });
+    return void 0;
+  }
+  const orderedFrames = orderAnimationFrames(clip);
+  const explicitActiveFrameId = readString(value.activeFrameId);
+  const explicitFrameIndex = readNonNegativeInteger(value.currentFrameIndex);
+  const frameIndex = explicitActiveFrameId !== void 0 ? orderedFrames.findIndex((frame2) => frame2.id === explicitActiveFrameId) : explicitFrameIndex ?? 0;
+  const frame = orderedFrames[frameIndex];
+  if (!frame || frameIndex < 0) {
+    const frameId = explicitActiveFrameId ?? String(explicitFrameIndex ?? 0);
+    diagnostics.push({
+      severity: "warning",
+      code: "PIXI_ANIMATION_FRAME_UNRESOLVED",
+      entityId,
+      path: `$.entities[${JSON.stringify(entityId)}].components.Animator.activeFrameId`,
+      message: `Animator activeFrameId '${frameId}' cannot be resolved in clip '${activeClip}'.`,
+      suggestion: "Run scene validation and ensure activeFrameId references a SpriteFrame in the active clip."
+    });
+    return void 0;
+  }
+  const elapsedFrames = readNonNegativeInteger(value.elapsedFrames);
+  const elapsedSeconds = readFiniteNumber(value.elapsedSeconds);
+  const asset = frame.sprite ? resolveDisplayAssetReference(entityId, frame.sprite, assetsById, diagnostics) : void 0;
+  return {
+    activeClip,
+    activeFrameId: frame.id,
+    frameIndex,
+    ...frame.sprite ? { sprite: frame.sprite } : {},
+    ...frame.rect ? { rect: frame.rect } : {},
+    ...asset ? { asset } : {},
+    ...asset?.atlasFrame ? { atlasFrame: asset.atlasFrame } : {},
+    ...elapsedFrames !== void 0 ? { elapsedFrames } : {},
+    ...elapsedSeconds !== void 0 ? { elapsedSeconds } : {}
+  };
+}
+function orderAnimationFrames(clip) {
+  if (!clip.frameOrder || clip.frameOrder.length === 0) {
+    return clip.frames;
+  }
+  const framesById = new Map(clip.frames.map((frame) => [frame.id, frame]));
+  return clip.frameOrder.flatMap((frameId) => {
+    const frame = framesById.get(frameId);
+    return frame ? [frame] : [];
+  });
+}
+function collectDisplayAssets(assets) {
+  if (!assets) {
+    return void 0;
+  }
+  return new Map(assets.map((asset) => [asset.id, asset]));
+}
+function readManifestOrAssetDefinitions(value, diagnostics) {
+  if (Array.isArray(value)) {
+    return readManifestAssets(value, diagnostics);
+  }
+  const document = readManifestDocument(value, diagnostics);
+  return document ? readManifestAssets(document.assets, diagnostics) : [];
+}
+function readManifestDocument(value, diagnostics) {
+  const document = parseManifestValue(value, diagnostics);
+  if (!isRecord(document)) {
+    diagnostics.push({
+      severity: "error",
+      code: "PIXI_ASSET_MANIFEST_INVALID",
+      path: "$",
+      message: "Asset manifest must be an object.",
+      suggestion: "Pass parsed Asset Manifest v0 JSON with version and assets."
+    });
+    return void 0;
+  }
+  if (!Array.isArray(document.assets)) {
+    diagnostics.push({
+      severity: "error",
+      code: "PIXI_ASSET_MANIFEST_ASSETS_MISSING",
+      path: "$.assets",
+      message: "Asset manifest is missing an assets array.",
+      suggestion: "Add assets: [] entries with stable ids, types, and paths."
+    });
+    return void 0;
+  }
+  return {
+    assets: document.assets
+  };
+}
+function parseManifestValue(value, diagnostics) {
+  if (typeof value !== "string") {
+    return value;
+  }
+  try {
+    return JSON.parse(value);
+  } catch (error) {
+    diagnostics.push({
+      severity: "error",
+      code: "PIXI_ASSET_MANIFEST_PARSE_FAILED",
+      path: "$",
+      message: error instanceof Error ? error.message : String(error),
+      suggestion: "Pass parsed JSON or a valid JSON string."
+    });
+    return void 0;
+  }
+}
+function readManifestAssets(assets, diagnostics) {
+  const assetsById = /* @__PURE__ */ new Map();
+  for (const [index, value] of assets.entries()) {
+    const assetPath = `$.assets[${index}]`;
+    if (!isRecord(value)) {
+      diagnostics.push({
+        severity: "error",
+        code: "PIXI_ASSET_INVALID",
+        path: assetPath,
+        message: "Asset entry must be an object.",
+        suggestion: "Use asset entries with id, type, and path fields."
+      });
+      continue;
+    }
+    const id = readString(value.id);
+    if (!id) {
+      diagnostics.push({
+        severity: "error",
+        code: "PIXI_ASSET_ID_MISSING",
+        path: `${assetPath}.id`,
+        message: "Asset entry is missing a stable id.",
+        suggestion: "Add a non-empty asset id and reference that id from SpriteFrame.sprite."
+      });
+      continue;
+    }
+    if (assetsById.has(id)) {
+      diagnostics.push({
+        severity: "error",
+        code: "PIXI_ASSET_DUPLICATE_ID",
+        path: `${assetPath}.id`,
+        message: `Duplicate asset id '${id}'.`,
+        suggestion: "Use one stable asset id once in the manifest."
+      });
+      continue;
+    }
+    const type = readString(value.type);
+    if (!type || !supportedManifestAssetTypes.has(type)) {
+      diagnostics.push({
+        severity: "error",
+        code: "PIXI_ASSET_TYPE_UNSUPPORTED",
+        path: `${assetPath}.type`,
+        message: `Asset '${id}' has unsupported type '${String(value.type)}'.`,
+        suggestion: "Use one of: texture, sprite, atlas, audio, font."
+      });
+      continue;
+    }
+    const sourcePath = readString(value.path);
+    if (!sourcePath) {
+      diagnostics.push({
+        severity: "error",
+        code: "PIXI_ASSET_PATH_MISSING",
+        path: `${assetPath}.path`,
+        message: `Asset '${id}' is missing a source path.`,
+        suggestion: "Add a project-relative path. The renderer helper validates metadata only and does not load the file."
+      });
+      continue;
+    }
+    const asset = createAssetDefinition(id, type, sourcePath, value, assetPath, diagnostics);
+    assetsById.set(id, asset);
+  }
+  validateManifestAssetReferences(assetsById, diagnostics);
+  return [...assetsById.values()].sort((left, right) => left.id.localeCompare(right.id));
+}
+function createAssetDefinition(id, type, sourcePath, value, assetPath, diagnostics) {
+  if (type === "sprite") {
+    const texture = readString(value.texture);
+    const atlas = readString(value.atlas);
+    const frame = readString(value.frame);
+    const rect = readManifestSpriteRect(value.rect, assetPath, id, diagnostics);
+    return {
+      id,
+      type,
+      path: sourcePath,
+      ...texture ? { texture } : {},
+      ...atlas ? { atlas } : {},
+      ...frame ? { frame } : {},
+      ...rect ? { rect } : {}
+    };
+  }
+  if (type === "atlas") {
+    const texture = readString(value.texture);
+    return {
+      id,
+      type,
+      path: sourcePath,
+      ...texture ? { texture } : {},
+      frames: readManifestAtlasFrames(value.frames, assetPath, id, diagnostics)
+    };
+  }
+  return {
+    id,
+    type,
+    path: sourcePath
+  };
+}
+function readManifestAtlasFrames(value, assetPath, atlasId, diagnostics) {
+  if (!Array.isArray(value)) {
+    diagnostics.push({
+      severity: "error",
+      code: "PIXI_ASSET_ATLAS_FRAMES_MISSING",
+      path: `${assetPath}.frames`,
+      message: `Atlas asset '${atlasId}' is missing a frames array.`,
+      suggestion: "Add frame entries with stable ids and [x, y, width, height] rect metadata."
+    });
+    return [];
+  }
+  const framesById = /* @__PURE__ */ new Map();
+  for (const [index, frame] of value.entries()) {
+    const framePath = `${assetPath}.frames[${index}]`;
+    if (!isRecord(frame)) {
+      diagnostics.push({
+        severity: "error",
+        code: "PIXI_ASSET_ATLAS_FRAME_INVALID",
+        path: framePath,
+        message: `Atlas frame entry in '${atlasId}' must be an object.`,
+        suggestion: "Use frame entries with id and rect fields."
+      });
+      continue;
+    }
+    const frameId = readString(frame.id);
+    if (!frameId) {
+      diagnostics.push({
+        severity: "error",
+        code: "PIXI_ASSET_ATLAS_FRAME_ID_MISSING",
+        path: `${framePath}.id`,
+        message: `Atlas asset '${atlasId}' has a frame without a stable id.`,
+        suggestion: "Add a non-empty frame id and reference it from SpriteAsset.frame."
+      });
+      continue;
+    }
+    if (framesById.has(frameId)) {
+      diagnostics.push({
+        severity: "error",
+        code: "PIXI_ASSET_ATLAS_DUPLICATE_FRAME_ID",
+        path: `${framePath}.id`,
+        message: `Atlas asset '${atlasId}' defines duplicate frame id '${frameId}'.`,
+        suggestion: "Use each frame id once per atlas."
+      });
+      continue;
+    }
+    const rect = readManifestAtlasFrameRect(frame.rect, framePath, atlasId, frameId, diagnostics);
+    if (!rect) {
+      continue;
+    }
+    framesById.set(frameId, {
+      id: frameId,
+      rect
+    });
+  }
+  return [...framesById.values()].sort((left, right) => left.id.localeCompare(right.id));
+}
+function readManifestAtlasFrameRect(value, framePath, atlasId, frameId, diagnostics) {
+  if (!Array.isArray(value) || value.length !== 4) {
+    diagnostics.push({
+      severity: "error",
+      code: "PIXI_ASSET_ATLAS_FRAME_RECT_INVALID",
+      path: `${framePath}.rect`,
+      message: `Atlas frame '${frameId}' in atlas '${atlasId}' rect must be [x, y, width, height].`,
+      suggestion: "Use four finite numbers. The Pixi helper records metadata only and does not slice atlases."
+    });
+    return void 0;
+  }
+  const invalidIndex = value.findIndex((item) => typeof item !== "number" || !Number.isFinite(item));
+  if (invalidIndex !== -1) {
+    diagnostics.push({
+      severity: "error",
+      code: "PIXI_ASSET_ATLAS_FRAME_RECT_INVALID",
+      path: `${framePath}.rect[${invalidIndex}]`,
+      message: `Atlas frame '${frameId}' in atlas '${atlasId}' rect value at index ${invalidIndex} must be a finite number.`,
+      suggestion: "Use numeric [x, y, width, height] atlas metadata."
+    });
+    return void 0;
+  }
+  const rect = [value[0], value[1], value[2], value[3]];
+  if (rect[2] <= 0 || rect[3] <= 0) {
+    diagnostics.push({
+      severity: "error",
+      code: "PIXI_ASSET_ATLAS_FRAME_RECT_INVALID",
+      path: `${framePath}.rect[${rect[2] <= 0 ? 2 : 3}]`,
+      message: `Atlas frame '${frameId}' in atlas '${atlasId}' rect width and height must be greater than zero.`,
+      suggestion: "Use positive width and height values. Atlas slicing remains caller-owned."
+    });
+    return void 0;
+  }
+  return rect;
+}
+function readManifestSpriteRect(value, assetPath, assetId, diagnostics) {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (!Array.isArray(value) || value.length !== 4) {
+    diagnostics.push({
+      severity: "error",
+      code: "PIXI_ASSET_RECT_INVALID",
+      path: `${assetPath}.rect`,
+      message: `Sprite asset '${assetId}' rect must be [x, y, width, height].`,
+      suggestion: "Use four finite numbers. The Pixi helper records metadata only and does not slice atlases."
+    });
+    return void 0;
+  }
+  const invalidIndex = value.findIndex((item) => typeof item !== "number" || !Number.isFinite(item));
+  if (invalidIndex !== -1) {
+    diagnostics.push({
+      severity: "error",
+      code: "PIXI_ASSET_RECT_INVALID",
+      path: `${assetPath}.rect[${invalidIndex}]`,
+      message: `Sprite asset '${assetId}' rect value at index ${invalidIndex} must be a finite number.`,
+      suggestion: "Use numeric [x, y, width, height] atlas planning metadata."
+    });
+    return void 0;
+  }
+  const rect = [value[0], value[1], value[2], value[3]];
+  if (rect[2] <= 0 || rect[3] <= 0) {
+    diagnostics.push({
+      severity: "error",
+      code: "PIXI_ASSET_RECT_INVALID",
+      path: `${assetPath}.rect[${rect[2] <= 0 ? 2 : 3}]`,
+      message: `Sprite asset '${assetId}' rect width and height must be greater than zero.`,
+      suggestion: "Use positive width and height values. Atlas slicing remains caller-owned."
+    });
+    return void 0;
+  }
+  return rect;
+}
+function validateManifestAssetReferences(assetsById, diagnostics) {
+  for (const asset of assetsById.values()) {
+    if (asset.type === "sprite") {
+      if (asset.texture) {
+        validateManifestReferenceToType({
+          assetsById,
+          diagnostics,
+          path: `$.assets[${JSON.stringify(asset.id)}].texture`,
+          ownerType: "Sprite asset",
+          assetId: asset.id,
+          referencedId: asset.texture,
+          expectedType: "texture",
+          missingCode: "PIXI_ASSET_REFERENCE_UNRESOLVED",
+          mismatchCode: "PIXI_ASSET_REFERENCE_TYPE_MISMATCH",
+          suggestion: "Add the referenced texture asset or remove the texture link until atlas loading exists."
+        });
+      }
+      validateManifestSpriteAtlasFrameReference(asset, assetsById, diagnostics);
+      continue;
+    }
+    if (asset.type === "atlas" && asset.texture) {
+      validateManifestReferenceToType({
+        assetsById,
+        diagnostics,
+        path: `$.assets[${JSON.stringify(asset.id)}].texture`,
+        ownerType: "Atlas asset",
+        assetId: asset.id,
+        referencedId: asset.texture,
+        expectedType: "texture",
+        missingCode: "PIXI_ASSET_ATLAS_TEXTURE_REFERENCE_UNRESOLVED",
+        mismatchCode: "PIXI_ASSET_ATLAS_TEXTURE_TYPE_MISMATCH",
+        suggestion: "Point atlas.texture to a texture asset id or remove the texture reference."
+      });
+    }
+  }
+}
+function validateManifestReferenceToType(input) {
+  const referenced = input.assetsById.get(input.referencedId);
+  if (!referenced) {
+    input.diagnostics.push({
+      severity: "error",
+      code: input.missingCode,
+      path: input.path,
+      message: `${input.ownerType} '${input.assetId}' references missing ${input.expectedType} asset '${input.referencedId}'.`,
+      suggestion: input.suggestion
+    });
+    return;
+  }
+  if (referenced.type !== input.expectedType) {
+    input.diagnostics.push({
+      severity: "error",
+      code: input.mismatchCode,
+      path: input.path,
+      message: `${input.ownerType} '${input.assetId}' references '${input.referencedId}', but it is '${referenced.type}', not '${input.expectedType}'.`,
+      suggestion: input.suggestion
+    });
+  }
+}
+function validateManifestSpriteAtlasFrameReference(asset, assetsById, diagnostics) {
+  if (!asset.atlas && !asset.frame) {
+    return;
+  }
+  if (!asset.atlas || !asset.frame) {
+    diagnostics.push({
+      severity: "error",
+      code: "PIXI_ASSET_ATLAS_FRAME_REFERENCE_INCOMPLETE",
+      path: `$.assets[${JSON.stringify(asset.id)}].${asset.atlas ? "frame" : "atlas"}`,
+      message: `Sprite asset '${asset.id}' must set both atlas and frame when referencing atlas metadata.`,
+      suggestion: "Set atlas to an atlas asset id and frame to a frame id inside that atlas."
+    });
+    return;
+  }
+  const atlas = assetsById.get(asset.atlas);
+  if (!atlas) {
+    diagnostics.push({
+      severity: "error",
+      code: "PIXI_ASSET_ATLAS_REFERENCE_UNRESOLVED",
+      path: `$.assets[${JSON.stringify(asset.id)}].atlas`,
+      message: `Sprite asset '${asset.id}' references missing atlas asset '${asset.atlas}'.`,
+      suggestion: "Add the referenced atlas asset or update SpriteAsset.atlas."
+    });
+    return;
+  }
+  if (atlas.type !== "atlas") {
+    diagnostics.push({
+      severity: "error",
+      code: "PIXI_ASSET_ATLAS_REFERENCE_TYPE_MISMATCH",
+      path: `$.assets[${JSON.stringify(asset.id)}].atlas`,
+      message: `Sprite asset '${asset.id}' references '${asset.atlas}', but it is '${atlas.type}', not 'atlas'.`,
+      suggestion: "Point SpriteAsset.atlas to an atlas asset id."
+    });
+    return;
+  }
+  const frame = atlas.frames.find((candidate) => candidate.id === asset.frame);
+  if (!frame) {
+    diagnostics.push({
+      severity: "error",
+      code: "PIXI_ASSET_ATLAS_FRAME_REFERENCE_UNRESOLVED",
+      path: `$.assets[${JSON.stringify(asset.id)}].frame`,
+      message: `Sprite asset '${asset.id}' references missing frame '${asset.frame}' in atlas '${asset.atlas}'.`,
+      suggestion: "Use a frame id defined by the referenced atlas asset."
+    });
+  }
+}
+function resolveDisplayAssetReference(entityId, assetId, assetsById, diagnostics) {
+  if (!assetsById) {
+    return void 0;
+  }
+  const asset = assetsById.get(assetId);
+  if (!asset) {
+    diagnostics.push({
+      severity: "warning",
+      code: "PIXI_ANIMATION_ASSET_UNRESOLVED",
+      entityId,
+      path: `$.entities[${JSON.stringify(entityId)}].components.Animator.activeFrameId`,
+      message: `Animation sprite asset '${assetId}' cannot be resolved by the Pixi display list.`,
+      suggestion: "Pass the project asset manifest assets to the renderer or update SpriteFrame.sprite to a known sprite asset id."
+    });
+    return void 0;
+  }
+  if (asset.type !== "sprite") {
+    diagnostics.push({
+      severity: "warning",
+      code: "PIXI_ANIMATION_ASSET_TYPE_MISMATCH",
+      entityId,
+      path: `$.entities[${JSON.stringify(entityId)}].components.Animator.activeFrameId`,
+      message: `Animation sprite asset '${assetId}' is '${asset.type}', not 'sprite'.`,
+      suggestion: "Use a SpriteFrame.sprite id whose manifest asset type is 'sprite'."
+    });
+    return void 0;
+  }
+  const atlasFrame = resolveDisplayAtlasFrameReference(asset, assetsById);
+  if ((asset.atlas || asset.frame) && !atlasFrame) {
+    diagnostics.push({
+      severity: "warning",
+      code: "PIXI_ANIMATION_ATLAS_FRAME_UNRESOLVED",
+      entityId,
+      path: `$.entities[${JSON.stringify(entityId)}].components.Animator.activeFrameId`,
+      message: `Animation sprite asset '${assetId}' has atlas/frame metadata that cannot be resolved by the Pixi display list.`,
+      suggestion: "Run project validation and ensure SpriteAsset.atlas points to an atlas asset and SpriteAsset.frame points to an atlas frame id."
+    });
+  }
+  return {
+    id: asset.id,
+    type: "sprite",
+    path: asset.path,
+    ...typeof asset.texture === "string" ? { texture: asset.texture } : {},
+    ...asset.rect ? { rect: asset.rect } : {},
+    ...typeof asset.atlas === "string" ? { atlas: asset.atlas } : {},
+    ...typeof asset.frame === "string" ? { frame: asset.frame } : {},
+    ...atlasFrame ? { atlasFrame } : {}
+  };
+}
+function resolveDisplayAtlasFrameReference(asset, assetsById) {
+  if (!asset.atlas || !asset.frame) {
+    return void 0;
+  }
+  const atlas = assetsById.get(asset.atlas);
+  if (atlas?.type !== "atlas") {
+    return void 0;
+  }
+  const frame = atlas.frames.find((candidate) => candidate.id === asset.frame);
+  if (!frame) {
+    return void 0;
+  }
+  return {
+    atlas: atlas.id,
+    frame: frame.id,
+    rect: frame.rect,
+    ...typeof atlas.texture === "string" ? { texture: atlas.texture } : {}
+  };
+}
+function isRenderMetadataOnly(components) {
+  if (!components) {
+    return false;
+  }
+  const componentNames = Object.keys(components);
+  return componentNames.length > 0 && componentNames.every((name) => name === "AnimationClip");
+}
+function readTransform(value) {
+  if (!isRecord(value)) {
+    return void 0;
+  }
+  const position = readNumberPair(value.position);
+  const scale = readNumberPair(value.scale);
+  const rotation = typeof value.rotation === "number" && Number.isFinite(value.rotation) ? value.rotation : void 0;
+  if (!position || !scale || rotation === void 0) {
+    return void 0;
+  }
+  return {
+    position,
+    rotation,
+    scale
+  };
+}
+function readCollider(value) {
+  if (!isRecord(value) || value.shape !== "box") {
+    return void 0;
+  }
+  const size = readNumberPair(value.size);
+  if (!size || size[0] <= 0 || size[1] <= 0) {
+    return void 0;
+  }
+  return {
+    size
+  };
+}
+function readNumberPair(value) {
+  if (!Array.isArray(value) || value.length !== 2 || typeof value[0] !== "number" || typeof value[1] !== "number" || !Number.isFinite(value[0]) || !Number.isFinite(value[1])) {
+    return void 0;
+  }
+  return [value[0], value[1]];
+}
+function readNumberTuple(value, length) {
+  if (!Array.isArray(value) || value.length !== length) {
+    return void 0;
+  }
+  if (!value.every((item) => typeof item === "number" && Number.isFinite(item))) {
+    return void 0;
+  }
+  return [value[0], value[1], value[2], value[3]];
+}
+function readString(value) {
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function readFiniteNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function readNonNegativeInteger(value) {
+  return typeof value === "number" && Number.isInteger(value) && value >= 0 ? value : void 0;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function roundDeterministic(value) {
+  return Number(value.toFixed(12));
+}
+export {
+  createDisplayList,
+  createPixiAssetLoaderFromManifest,
+  createPixiAtlasTextureResolverFromManifest,
+  createPixiRenderer,
+  createPixiTextureResolverFromManifest,
+  renderWorld,
+  renderWorldSnapshot
+};
+//# sourceMappingURL=index.js.map