@forgeax/engine-gltf 0.1.4 → 0.1.6

package/src/__tests__/source-key-producer.integration.test.ts

@@ -86,7 +86,7 @@ describe('glTF producer source-key boundary', () => {
     expect(result.ok).toBe(false);
     if (result.ok) return;
     expect(result.error.code).toBe('duplicate-source-key');
-    expect(result.error.sourceIndices).toEqual([0, 1]);
+    expect(result.error.detail.sourceIndices).toEqual([0, 1]);
   });
 
   it('applies the same preflight to duplicate material names', () => {
@@ -95,7 +95,7 @@ describe('glTF producer source-key boundary', () => {
     expect(result.ok).toBe(false);
     if (result.ok) return;
     expect(result.error.code).toBe('duplicate-source-key');
-    expect(result.error.sourceIndices).toEqual([0, 1]);
+    expect(result.error.detail.sourceIndices).toEqual([0, 1]);
   });
 
   it('publishes producer-valid output when semantic identity is unique', () => {

package/src/bridge.ts

@@ -424,17 +424,16 @@ export interface GltfBridgeContext {
   /**
    * glTF skin index -> SkeletonAsset GUID (string form). When a GltfNodeIr carries
    * a skin reference, the bridge emits `Skin: { skeleton: <guid-string> }` on
-   * that node's entity; the World scene owner resolves the GUID to a shared ref
-   * at `world.instantiateScene` time (same protocol as MeshFilter and
+   * that node's entity; AssetRegistry._resolveSceneGuids resolves the GUID to
+   * a runtime Handle at instantiate time (same protocol as MeshFilter and
    * MeshRenderer.materials[]). Optional — skinless glTFs pass an empty Map
    * (or omit the field) and the bridge does not emit Skin.
    *
    * tweak-20260611 M6 / D-7: emitting Skin from the bridge means the standard
-   * typed `assets.load(sceneGuid, sceneAssetKind)` + `world.instantiateScene`
-   * path Just Works for skinned glTF;
+   * loadByGuid<SceneAsset> + instantiate path Just Works for skinned glTF;
    * demos no longer need to runtime-parseGlb + post-load patch the SceneAsset.
-   * postSpawnResolveJoints walks the matching SkinAsset.jointPaths against the
-   * spawn subtree to fill Skin.joints[].
+   * postSpawnResolveJoints (called from AssetRegistry.instantiate) walks the
+   * matching SkinAsset.jointPaths against the spawn subtree to fill Skin.joints[].
    */
   readonly skeletonGuidBySkinIndex?: ReadonlyMap<number, string>;
 }
@@ -648,10 +647,10 @@ export function gltfDocToSceneAsset(doc: GltfDoc, ctx: GltfBridgeContext): Scene
       }
       // tweak-20260611 M6: when this node references a glTF skin, stamp a
       // Skin component carrying the SkeletonAsset GUID as a string. The
-      // the World scene owner resolves the string to a shared ref at
-      // instantiate time (same protocol as MeshFilter/MeshRenderer).
-      // postSpawnResolveJoints then fills Skin.joints[] by walking the matching
-      // SkinAsset.jointPaths
+      // runtime AssetRegistry._resolveSceneGuids resolves the string to a
+      // Handle at instantiate time (same protocol as MeshFilter/MeshRenderer).
+      // postSpawnResolveJoints (called from AssetRegistry.instantiate) then
+      // fills Skin.joints[] by walking the matching SkinAsset.jointPaths
       // against the spawn subtree's Name index.
       if (ir.skinIndex !== null && ctx.skeletonGuidBySkinIndex !== undefined) {
         const skeletonGuid = ctx.skeletonGuidBySkinIndex.get(ir.skinIndex);

package/src/check-extensions.ts

@@ -1,7 +1,7 @@
 // check-extensions.ts - KHR / vendor extension gate.
 //
-// v1 required-extension support contains EXT_mesh_gpu_instancing and
-// KHR_lights_punctual. The exported legacy list remains the original mesh
+// v1 required-extension support contains EXT_mesh_gpu_instancing,
+// KHR_lights_punctual, and KHR_texture_transform. The exported legacy list remains the original mesh
 // extension list for callers that display the v1 mesh-only surface.
 // (feat-20260518-gltf-instancing-and-name-component plan-strategy section
 // 2 D-1 / D-3). Any extension listed in `extensionsRequired[]` outside
@@ -15,7 +15,7 @@
 // material). A stderr warn for those would be a false positive, so the
 // diagnostics list is the single channel (no `console.error`).
 //
-// Future expansion (KHR_materials_unlit, KHR_texture_transform, ...) extends
+// Future expansion (KHR_materials_unlit, ...) extends
 // `EXTENSION_ALLOWLIST` in place; each addition lands under its own feat-*
 // loop with breaking-change registry entry.
 
@@ -26,7 +26,11 @@ export const EXTENSION_ALLOWLIST: readonly string[] = [
   'EXT_mesh_gpu_instancing',
   'EXT_meshopt_compression',
 ];
-const SUPPORTED_EXTENSIONS: readonly string[] = [...EXTENSION_ALLOWLIST, 'KHR_lights_punctual'];
+const SUPPORTED_EXTENSIONS: readonly string[] = [
+  ...EXTENSION_ALLOWLIST,
+  'KHR_lights_punctual',
+  'KHR_texture_transform',
+];
 
 export interface ExtensionsCheckResult {
   /** Names listed in extensionsUsed but not in the allowlist. */

package/src/cli-gltf.ts

@@ -314,12 +314,7 @@ async function runWrite(target: string, ctx: AssetCtx): Promise<number> {
     sourceRelative,
   );
   if (!pack.ok) {
-    return emitError(ctx, {
-      code: pack.error.code,
-      expected: pack.error.expected,
-      hint: pack.error.hint,
-      detail: { source: sourceRelative, sourceIndices: pack.error.sourceIndices },
-    });
+    return emitError(ctx, pack.error);
   }
   await writeFile(metaPath, serializeMetaJson(pack.value.meta), 'utf-8');
   return 0;

package/src/gltf-importer.ts

@@ -531,8 +531,7 @@ async function importGltf(
   // share `sourceIndex` (toAssetPack emits 1:1 per GltfSkeletonRecord) but live
   // as distinct `kind` sub-assets, so the SkinAsset GUIDs differ from the
   // SkeletonAsset GUIDs. The scene branch below appends these GUIDs to both
-  // its refs[] (the runtime recursion source: assets.load(sceneGuid,
-  // sceneAssetKind) walks
+  // its refs[] (the runtime recursion source: loadByGuid<SceneAsset> walks
   // envelope.refs to recursively pull every SkinAsset before instantiate) and
   // its payload.skinGuids (the reverse-decode hint) -- without the refs[] edge,
   // browser-async-pack-fetch never loads SkinAssets and Skin.joints stays

package/src/index.ts

@@ -131,6 +131,7 @@ export {
 // Byte-stable meta JSON serialization (D-3; AC-04).
 export { serializeMetaJson } from './serialize-meta.js';
 export type {
+  GltfSourceKeyConflictEntry,
   GltfSourceKeyError,
   GltfSourceKeyErrorCode,
   GltfSourceKeyResult,

package/src/parse-gltf.ts

@@ -58,7 +58,7 @@ export interface MeshJson {
 // === Tier-B v1 IR (GltfDoc) ===
 //
 // Shape: a denormalised view of the parsed glTF JSON, post-validation,
-// suitable for downstream `toAssetPack` and the typed runtime asset owners
+// suitable for downstream `toAssetPack` and runtime AssetRegistry
 // hand-off. Math types are POD (number tuples), no Vec3/Quat brand at
 // the boundary (charter proposition 5).
 
@@ -1582,8 +1582,8 @@ export function toAssetPack(
   // requirements G-2 / AC-13). Orphan images (declared but unreferenced by
   // any `textures[]` row) still produce a sub-asset; the importer assigns
   // them colorSpace 'linear' (no colour-encoded purpose inferable). Without
-  // this loop the meta carries no `kind: 'texture'` row, the runtime catalog
-  // never imports the bytes, and the asset consumer renders a white box (G-2).
+  // this loop the meta carries no `kind: 'texture'` row, AssetRegistry
+  // never imports the bytes, and the runtime renders a white box (G-2).
   const images = doc.images ?? [];
   for (let i = 0; i < images.length; i++) {
     const img = images[i];
@@ -1680,10 +1680,12 @@ export function toAssetPack(
     if (!reconciled.ok) {
       return err({
         code: 'mesh-material-slot-topology-change',
-        sourceIndices: reconciled.error.nextIndices,
-        previousIndices: reconciled.error.previousIndices,
         expected: `unambiguous material slot identity for mesh ${meshOutput.guid}`,
         hint: reconciled.error.hint,
+        detail: {
+          sourceIndices: reconciled.error.nextIndices,
+          previousIndices: reconciled.error.previousIndices,
+        },
       });
     }
     sourceOverrides[meshOutput.sourceKey] = {

package/src/source-key.ts

@@ -1,17 +1,37 @@
 import type { GltfDocItemLike } from './sub-asset-key.js';
 
-export interface GltfSourceKeyError {
-  readonly code:
-    | 'missing-source-key'
-    | 'duplicate-source-key'
-    | 'ambiguous-source-key'
-    | 'mesh-material-slot-topology-change';
-  readonly sourceIndices: readonly number[];
+interface GltfSourceKeyErrorBase {
   readonly expected: string;
   readonly hint: string;
-  readonly previousIndices?: readonly number[];
 }
 
+export interface GltfSourceKeyConflictEntry {
+  readonly kind: string;
+  readonly name: string | null;
+  readonly sourceIndex: number;
+}
+
+export type GltfSourceKeyError =
+  | (GltfSourceKeyErrorBase & {
+      readonly code: 'missing-source-key';
+      readonly detail: { readonly sourceIndices: readonly number[] };
+    })
+  | (GltfSourceKeyErrorBase & {
+      readonly code: 'duplicate-source-key' | 'ambiguous-source-key';
+      readonly detail: {
+        readonly key: string;
+        readonly sourceIndices: readonly number[];
+        readonly entries: readonly GltfSourceKeyConflictEntry[];
+      };
+    })
+  | (GltfSourceKeyErrorBase & {
+      readonly code: 'mesh-material-slot-topology-change';
+      readonly detail: {
+        readonly sourceIndices: readonly number[];
+        readonly previousIndices: readonly number[];
+      };
+    });
+
 export type GltfSourceKeyErrorCode = GltfSourceKeyError['code'];
 
 export type GltfSourceKeyResult =
@@ -39,33 +59,47 @@ export function deriveGltfSourceKeys(items: readonly GltfDocItemLike[]): GltfSou
       ok: false,
       error: {
         code: 'missing-source-key',
-        sourceIndices: missing,
         expected: 'every glTF output needs a stable semantic kind or name',
         hint: 'publish a semantic kind/name key; do not use sourceIndex',
+        detail: { sourceIndices: missing },
       },
     };
   }
 
-  const seen = new Map<string, number>();
+  const seen = new Map<string, GltfDocItemLike>();
   for (let index = 0; index < keys.length; index++) {
     const key = keys[index];
     if (key === undefined) continue;
+    const current = items[index];
+    if (current === undefined) continue;
     const prior = seen.get(key);
     if (prior !== undefined) {
+      const entry = (item: GltfDocItemLike): GltfSourceKeyConflictEntry => {
+        const name = item.name?.trim();
+        return {
+          kind: item.kind.trim(),
+          name: name === undefined || name.length === 0 ? null : name,
+          sourceIndex: item.sourceIndex,
+        };
+      };
+      const ambiguous = key === current.kind.trim();
       return {
         ok: false,
         error: {
-          code: key === items[index]?.kind ? 'ambiguous-source-key' : 'duplicate-source-key',
-          sourceIndices: [prior, items[index]?.sourceIndex ?? 0],
+          code: ambiguous ? 'ambiguous-source-key' : 'duplicate-source-key',
           expected: 'sourceKey values must be unique within one glTF package',
-          hint:
-            key === items[index]?.kind
-              ? 'name each otherwise anonymous output; do not use sourceIndex'
-              : 'rename duplicate outputs before publishing topology facts',
+          hint: ambiguous
+            ? 'name each otherwise anonymous output; do not use sourceIndex'
+            : 'rename duplicate outputs before publishing topology facts',
+          detail: {
+            key,
+            sourceIndices: [prior.sourceIndex, current.sourceIndex],
+            entries: [entry(prior), entry(current)],
+          },
         },
       };
     }
-    seen.set(key, items[index]?.sourceIndex ?? 0);
+    seen.set(key, current);
   }
 
   return { ok: true, keys: keys as string[], conflicts: [] };

package/dist/__tests__/asset-runtime-fixture.d.ts

@@ -1,14 +0,0 @@
-import { type AssetRegistry } from '@forgeax/engine-assets-runtime';
-import { type DdcPack } from '@forgeax/engine-import';
-import type { AssetDecoder, MeshAsset } from '@forgeax/engine-types';
-type FixtureAsset = DdcPack['assets'][number];
-export interface AssetRuntimeFixtureOptions {
-    readonly packageUrl?: string;
-    readonly artifactOverrides?: ReadonlyMap<string, Uint8Array>;
-}
-export declare const normalizedMeshAssetDecoder: AssetDecoder<MeshAsset>;
-export declare function installMeshDecoder(assets: AssetRegistry): import("@forgeax/engine-types").AssetDecoderLease;
-export declare function installPassthroughDecoder(assets: AssetRegistry, kind: string): import("@forgeax/engine-types").AssetDecoderLease;
-export declare function createAssetRuntimeFixture(sourceAssets: readonly FixtureAsset[], options?: AssetRuntimeFixtureOptions): AssetRegistry;
-export {};
-//# sourceMappingURL=asset-runtime-fixture.d.ts.map

package/dist/__tests__/asset-runtime-fixture.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"asset-runtime-fixture.d.ts","sourceRoot":"","sources":["../../src/__tests__/asset-runtime-fixture.ts"],"names":[],"mappings":"AACA,OAAO,EACL,KAAK,aAAa,EAGnB,MAAM,gCAAgC,CAAC;AAExC,OAAO,EAAE,KAAK,OAAO,EAAoB,MAAM,wBAAwB,CAAC;AACxE,OAAO,KAAK,EACV,YAAY,EAGZ,SAAS,EAIV,MAAM,uBAAuB,CAAC;AAwB/B,KAAK,YAAY,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,CAAC;AAE9C,MAAM,WAAW,0BAA0B;IACzC,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,iBAAiB,CAAC,EAAE,WAAW,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;CAC9D;AAoID,eAAO,MAAM,0BAA0B,EAAE,YAAY,CAAC,SAAS,CAqB9D,CAAC;AAEF,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,aAAa,qDAEvD;AAED,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,aAAa,EAAE,IAAI,EAAE,MAAM,qDAS5E;AAED,wBAAgB,yBAAyB,CACvC,YAAY,EAAE,SAAS,YAAY,EAAE,EACrC,OAAO,GAAE,0BAA+B,GACvC,aAAa,CA2Df"}

package/src/__tests__/asset-runtime-fixture.ts

@@ -1,278 +0,0 @@
-import { createHash } from 'node:crypto';
-import {
-  type AssetRegistry,
-  createAssetRegistry,
-  createCatalogSource,
-} from '@forgeax/engine-assets-runtime';
-import { meshAssetDecoder, meshAssetKind } from '@forgeax/engine-geometry';
-import { type DdcPack, normaliseForPack } from '@forgeax/engine-import';
-import type {
-  AssetDecoder,
-  AssetKind,
-  AssetLoadError,
-  MeshAsset,
-  MorphTarget,
-  Result,
-  VertexAttributeMap,
-} from '@forgeax/engine-types';
-import { err, ok } from '@forgeax/engine-types';
-
-const SCOPE_ID = 'gltf-test-scope';
-const GENERATION = 1;
-const PACK_DIGEST = `sha256:${'1'.repeat(64)}`;
-const OUTPUT_SET_DIGEST = `sha256:${'2'.repeat(64)}`;
-const OUTPUT_DIGEST = `sha256:${'3'.repeat(64)}`;
-const ATTRIBUTE_KEYS = [
-  'position',
-  'normal',
-  'uv',
-  'tangent',
-  'skinIndex',
-  'skinWeight',
-  'uv1',
-  'uv2',
-  'uv3',
-  'uv4',
-  'uv5',
-  'uv6',
-  'uv7',
-] as const;
-
-type FixtureAsset = DdcPack['assets'][number];
-
-export interface AssetRuntimeFixtureOptions {
-  readonly packageUrl?: string;
-  readonly artifactOverrides?: ReadonlyMap<string, Uint8Array>;
-}
-
-function sha256(bytes: Uint8Array): string {
-  return `sha256:${createHash('sha256').update(bytes).digest('hex')}`;
-}
-
-function row(asset: FixtureAsset, packageUrl: string) {
-  const sourcePath = `fixtures/${asset.guid}`;
-  return {
-    guid: asset.guid,
-    packageUrl,
-    kind: asset.kind,
-    sourcePath,
-    revision: { rootId: 'gltf-fixture', digest: 'sha256:catalog', observedAt: 1 },
-    publication: {
-      schemaVersion: 'asset-publication/1' as const,
-      sourcePath,
-      sourceRevision: 'gltf-fixture-source',
-      generation: GENERATION,
-      digest: PACK_DIGEST,
-      outputSetDigest: OUTPUT_SET_DIGEST,
-      outputs: [
-        {
-          guid: asset.guid,
-          sourceKey: asset.sourceKey ?? asset.guid,
-          kind: asset.kind,
-          digest: OUTPUT_DIGEST,
-          refs: asset.refs,
-        },
-      ],
-      receipt: {
-        schemaVersion: 'asset-publication-receipt/1' as const,
-        sourcePath,
-        sourceRevision: 'gltf-fixture-source',
-        inputFingerprint: 'gltf-fixture-input',
-        outputDigest: OUTPUT_DIGEST,
-        outputSetDigest: OUTPUT_SET_DIGEST,
-        externalEvidence: [],
-      },
-      externalEvidence: [],
-    },
-  };
-}
-
-function floatArray(value: unknown): Float32Array | undefined {
-  if (value instanceof Float32Array) return value;
-  if (value instanceof ArrayBuffer) return new Float32Array(value);
-  if (ArrayBuffer.isView(value))
-    return new Float32Array(Array.from(value as unknown as ArrayLike<number>));
-  if (Array.isArray(value)) return new Float32Array(value as number[]);
-  return undefined;
-}
-
-function indexArray(value: unknown): Uint16Array | Uint32Array | undefined {
-  if (value instanceof Uint16Array || value instanceof Uint32Array) return value;
-  if (ArrayBuffer.isView(value) || Array.isArray(value)) {
-    const values = Array.from(value as unknown as ArrayLike<number>);
-    return values.some((entry) => entry > 0xffff)
-      ? new Uint32Array(values)
-      : new Uint16Array(values);
-  }
-  return undefined;
-}
-
-function integerAttribute(value: unknown): Uint16Array | undefined {
-  if (value instanceof Uint16Array) return value;
-  if (Array.isArray(value) || ArrayBuffer.isView(value)) {
-    return new Uint16Array(Array.from(value as unknown as ArrayLike<number>));
-  }
-  return undefined;
-}
-
-function morphTarget(value: unknown): MorphTarget | undefined {
-  if (value === null || typeof value !== 'object') return undefined;
-  const source = value as Record<string, unknown>;
-  const position = floatArray(source.position);
-  const normal = floatArray(source.normal);
-  const tangent = floatArray(source.tangent);
-  return {
-    ...(position === undefined ? {} : { position }),
-    ...(normal === undefined ? {} : { normal }),
-    ...(tangent === undefined ? {} : { tangent }),
-  };
-}
-
-function meshPayload(value: unknown): MeshAsset | undefined {
-  if (value === null || typeof value !== 'object') return undefined;
-  const source = value as Record<string, unknown>;
-  const vertices = floatArray(source.vertices);
-  const rawAttributes = source.attributes;
-  const rawSubmeshes = source.submeshes;
-  const rawMaterialSlots = source.materialSlots;
-  if (
-    source.kind !== 'mesh' ||
-    vertices === undefined ||
-    rawAttributes === null ||
-    typeof rawAttributes !== 'object' ||
-    !Array.isArray(rawSubmeshes) ||
-    !Array.isArray(rawMaterialSlots)
-  ) {
-    return undefined;
-  }
-  const attributes: VertexAttributeMap = {};
-  const sourceAttributes = rawAttributes as Record<string, unknown>;
-  for (const key of ATTRIBUTE_KEYS) {
-    const raw = sourceAttributes[key];
-    if (raw === undefined) continue;
-    const converted = key === 'skinIndex' ? integerAttribute(raw) : floatArray(raw);
-    if (converted !== undefined) attributes[key] = converted;
-  }
-  const indices = indexArray(source.indices);
-  const aabb = floatArray(source.aabb);
-  const morphWeights = floatArray(source.morphWeights);
-  const morphTargets = Array.isArray(source.morphTargets)
-    ? source.morphTargets.flatMap((target) => {
-        const converted = morphTarget(target);
-        return converted === undefined ? [] : [converted];
-      })
-    : undefined;
-  return {
-    kind: 'mesh',
-    vertices,
-    ...(indices === undefined ? {} : { indices }),
-    attributes,
-    ...(aabb === undefined ? {} : { aabb }),
-    submeshes: rawSubmeshes as MeshAsset['submeshes'],
-    materialSlots: rawMaterialSlots as MeshAsset['materialSlots'],
-    ...(morphTargets === undefined ? {} : { morphTargets }),
-    ...(morphWeights === undefined ? {} : { morphWeights }),
-  };
-}
-
-export const normalizedMeshAssetDecoder: AssetDecoder<MeshAsset> = {
-  async decode(input): Promise<Result<MeshAsset, AssetLoadError>> {
-    const body = input.envelope.artifacts.body;
-    if (body !== undefined) {
-      const bytes = await input.artifacts.read(body);
-      if (!bytes.ok) return bytes;
-    }
-    const payload = meshPayload(input.envelope.payload);
-    if (payload === undefined) {
-      return err({
-        code: 'asset-package-invalid',
-        expected: 'a JSON-safe mesh payload that can be owned by Geometry',
-        hint: 'recook the mesh payload with typed vertex and attribute fields',
-        detail: { guid: input.envelope.guid, reason: 'mesh payload normalization failed' },
-      });
-    }
-    return meshAssetDecoder.decode({
-      ...input,
-      envelope: { ...input.envelope, payload },
-    });
-  },
-};
-
-export function installMeshDecoder(assets: AssetRegistry) {
-  return assets.installDecoder(meshAssetKind, normalizedMeshAssetDecoder);
-}
-
-export function installPassthroughDecoder(assets: AssetRegistry, kind: string) {
-  const token: AssetKind<Record<string, unknown>, string> = {
-    kind,
-  } as AssetKind<Record<string, unknown>, string>;
-  return assets.installDecoder(token, {
-    async decode({ envelope }) {
-      return ok(envelope.payload);
-    },
-  });
-}
-
-export function createAssetRuntimeFixture(
-  sourceAssets: readonly FixtureAsset[],
-  options: AssetRuntimeFixtureOptions = {},
-): AssetRegistry {
-  const packageUrl = options.packageUrl ?? 'https://assets.test/gltf-fixture.pack.json';
-  const artifactBytes = new Map<string, Uint8Array>();
-  const runtimeAssets = sourceAssets.map((asset) => {
-    const artifacts = Object.fromEntries(
-      Object.entries(asset.artifacts).map(([key, body]) => {
-        const path = `${asset.guid}/${key}.bin`;
-        const url = new URL(path, packageUrl).toString();
-        artifactBytes.set(
-          url,
-          options.artifactOverrides?.get(`${asset.guid}:${key}`) ?? body.bytes,
-        );
-        return [
-          key,
-          {
-            path,
-            mediaType: body.mediaType,
-            contentEncoding: 'identity' as const,
-            byteLength: body.bytes.byteLength,
-            integrity: { algorithm: 'sha256' as const, digest: sha256(body.bytes) },
-            ...(body.assetCodec === undefined ? {} : { assetCodec: body.assetCodec }),
-          },
-        ];
-      }),
-    );
-    return {
-      guid: asset.guid,
-      kind: asset.kind,
-      ...(asset.name === undefined ? {} : { name: asset.name }),
-      payload: normaliseForPack(asset.payload) as Record<string, unknown>,
-      refs: asset.refs,
-      artifacts,
-    };
-  });
-  const pack = {
-    schemaVersion: '2.0.0' as const,
-    kind: 'internal-text-package' as const,
-    scopeId: SCOPE_ID,
-    generation: GENERATION,
-    digest: PACK_DIGEST,
-    outputSetDigest: OUTPUT_SET_DIGEST,
-    assets: runtimeAssets,
-  };
-  const fetcher: typeof globalThis.fetch = async (input) => {
-    const url = String(input);
-    if (url === packageUrl) return new Response(JSON.stringify(pack));
-    const bytes = artifactBytes.get(url);
-    return bytes === undefined
-      ? new Response('not found', { status: 404 })
-      : new Response(bytes as unknown as BodyInit);
-  };
-  return createAssetRegistry({
-    catalog: createCatalogSource({
-      entries: sourceAssets.map((asset) => row(asset, packageUrl)),
-    }),
-    fetcher,
-    scopeId: SCOPE_ID,
-    generation: GENERATION,
-  });
-}