@forgeax/engine-assets-runtime 0.1.4 → 0.1.6

package/src/scene-handle-fields.ts

@@ -0,0 +1,221 @@
+// @forgeax/engine-assets-runtime — scene-handle-fields: shared reflection helper for
+// SceneAsset handle-field extraction (plan-strategy D-4 / requirements B-5).
+//
+// `_resolveSceneGuids` (instantiate) and `buildSceneChildContext` (breadcrumb)
+// consume this helper so the "identify shared<...> / array<shared<...>> schema
+// fields + read GUID string" logic has exactly one authoritative location
+// (Derive, Don't Duplicate).
+//
+// This helper returns raw GUID strings WITHOUT mutating the registry; resolution
+// to Handle numbers is the caller's responsibility.
+//
+// Both consumers prefer the structured `envelope.refs` edges (D-3) when an
+// envelope is catalogued for the scene, and fall back to this entity-component
+// walk only when no envelope (or no per-entity edge detail) is available:
+//  - `_resolveSceneGuids`: envelope-less scenes (e.g. unit tests that build a
+//    SceneAsset directly without cataloguing it; no `sceneGuidKey`).
+//  - `buildSceneChildContext`: prod GUID-only refs[] edges whose `sourceField`
+//    was stripped at the serialization boundary (w7 D-10), plus direct
+//    `catalog()` scene registration with no refs. The walk recovers the
+//    (entityLocalId, componentName, fieldName, arrayIndex) triple the bare
+//    edge no longer carries.
+
+import type { Component } from '@forgeax/engine-ecs';
+import { componentSchema } from '@forgeax/engine-ecs/internal';
+import type { MountOverride } from '@forgeax/engine-types';
+
+/**
+ * A single handle-field reference extracted from a SceneAsset entity.
+ *
+ * `entityLocalId` is the `node.localId`; `componentName` and `fieldName`
+ * identify the schema field whose `fieldType` starts with `shared\<` or
+ * `array\<shared\<`. `guidString` is the raw GUID string value from the
+ * entity's component data (NOT a parsed `AssetGuid` — callers parse or
+ * resolve as needed).
+ *
+ * `arrayIndex` is `undefined` for plain `handle<T>` fields; for
+ * `array<handle<T>>` fields it is the 0-based index into the array.
+ */
+export interface SceneHandleFieldEntry {
+  readonly entityLocalId: number;
+  readonly componentName: string;
+  readonly fieldName: string;
+  readonly guidString: string;
+  /** 0-based index for `array<handle<T>>` elements; `undefined` for plain `handle<T>` fields. */
+  readonly arrayIndex?: number;
+}
+
+/**
+ * Shape of a single entity passed to {@link extractSceneEntityHandleGuids}.
+ *
+ * Compatible with both `SceneEntity` (from `@forgeax/engine-types`, where
+ * `components` is `Partial<ComponentValuesMap>`) and test-side plain objects.
+ */
+interface SceneEntityLike {
+  readonly localId: number;
+  readonly components: Record<string, Record<string, unknown>>;
+}
+
+/**
+ * Walk every `SceneEntityLike` in `entities` and extract all GUID strings
+ * bound to schema fields with `handle<...>` or `array<handle<...>>` fieldType.
+ *
+ * Unknown component names (absent from the supplied World-local catalog) are
+ * silently skipped — the ecs layer's `additionalProperties` check will catch
+ * unknowns at spawn time if appropriate.
+ *
+ * Values that are already numbers (resolved Handles) or non-strings are
+ * skipped (they are not GUID refs).
+ *
+ * @internal Shared by {@link AssetRegistry._resolveSceneGuids} and
+ * `buildSceneChildContext` as the entity-walk fallback used when the structured
+ * `envelope.refs` edges are unavailable or carry no per-entity detail.
+ */
+export function extractSceneEntityHandleGuids(
+  components: ReadonlyMap<string, Component>,
+  entities: ReadonlyArray<SceneEntityLike>,
+): SceneHandleFieldEntry[] {
+  const entries: SceneHandleFieldEntry[] = [];
+
+  for (const node of entities) {
+    const rawComponents: Record<string, Record<string, unknown>> = node.components as Record<
+      string,
+      Record<string, unknown>
+    >;
+
+    for (const compName of Object.keys(rawComponents)) {
+      const rawFields = rawComponents[compName];
+      if (!rawFields) continue;
+
+      const comp = components.get(compName);
+      if (!comp) continue;
+
+      for (const fieldName of Object.keys(rawFields)) {
+        forEachHandleGuid(
+          componentSchema(comp)[fieldName],
+          rawFields[fieldName],
+          (guidString, arrayIndex) => {
+            entries.push({
+              entityLocalId: node.localId,
+              componentName: compName,
+              fieldName,
+              guidString,
+              ...(arrayIndex !== undefined ? { arrayIndex } : {}),
+            });
+          },
+        );
+      }
+    }
+  }
+
+  return entries;
+}
+
+/**
+ * One handle-field GUID reference extracted from a {@link MountOverride}'s value
+ * (feat-20260713 M3 / w12). Mirrors {@link SceneHandleFieldEntry} but keys on the
+ * override's array index (there is no entity `localId` — an override targets a
+ * mount member by its own `localId`, resolved by the ecs apply loop, not here).
+ *
+ * `fieldName` is the schema field the GUID binds to: the override's own `field`
+ * for the patch form, or a key of the component-add value map for the add form.
+ */
+export interface MountOverrideHandleFieldEntry {
+  /** 0-based index into the `overrides[]` array passed to the extractor. */
+  readonly overrideIndex: number;
+  readonly componentName: string;
+  readonly fieldName: string;
+  readonly guidString: string;
+  /** 0-based index for `array<shared<T>>` elements; `undefined` for scalar `shared<T>`. */
+  readonly arrayIndex?: number;
+}
+
+/**
+ * Walk `overrides` and extract every GUID string bound to a `shared<...>` /
+ * `array<shared<...>>` schema field inside each override's value (feat-20260713
+ * M3 / w12, plan-strategy D-2). This is the apply-side counterpart to
+ * {@link extractSceneEntityHandleGuids}: it feeds `resolveMountsRec`'s
+ * GUID→handle down-drill so a `mounts[].overrides[].value` carrying a raw GUID
+ * (e.g. an `AnimationPlayer.clips` clip GUID) resolves to a live handle before
+ * the ecs apply loop, which only ever sees numeric handles (D-2: the GUID domain
+ * stays sealed in assets-runtime).
+ *
+ * The `{comp, field?, value}` discriminant is normalized to `(fieldName, value)`
+ * pairs: the patch form (`field` present) yields one pair; the component-add form
+ * (`field` absent, `value` is a per-field map) yields one pair per value key.
+ * Field type is judged from the supplied catalog token schema, the same
+ * schema SSOT the entity walk uses. Unknown components / non-shared fields /
+ * non-string (already-resolved number) values are skipped (D-8 number pass-through).
+ *
+ * @internal Shared identification core; resolution lives in `resolveMountsRec`.
+ */
+export function extractMountOverrideHandleGuids(
+  components: ReadonlyMap<string, Component>,
+  overrides: ReadonlyArray<MountOverride>,
+): MountOverrideHandleFieldEntry[] {
+  const entries: MountOverrideHandleFieldEntry[] = [];
+
+  for (let overrideIndex = 0; overrideIndex < overrides.length; overrideIndex++) {
+    const ov = overrides[overrideIndex];
+    if (ov === undefined) continue;
+
+    const comp = components.get(ov.comp);
+    if (!comp) continue;
+
+    for (const [fieldName, value] of normalizeOverrideFields(ov)) {
+      forEachHandleGuid(componentSchema(comp)[fieldName], value, (guidString, arrayIndex) => {
+        entries.push({
+          overrideIndex,
+          componentName: ov.comp,
+          fieldName,
+          guidString,
+          ...(arrayIndex !== undefined ? { arrayIndex } : {}),
+        });
+      });
+    }
+  }
+
+  return entries;
+}
+
+/**
+ * Normalize a {@link MountOverride}'s `{comp, field?, value}` shape into
+ * `(fieldName, value)` pairs (feat-20260713 M3 / w12). Patch form (`field`
+ * present) → one pair; component-add form (`field` absent, `value` a per-field
+ * map) → one pair per value key. A non-object add value yields no pairs.
+ */
+function normalizeOverrideFields(ov: MountOverride): ReadonlyArray<readonly [string, unknown]> {
+  if (ov.field !== undefined) return [[ov.field, ov.value]];
+  const value = ov.value;
+  if (typeof value !== 'object' || value === null || Array.isArray(value)) return [];
+  const map = value as Record<string, unknown>;
+  return Object.keys(map).map((key) => [key, map[key]] as const);
+}
+
+/**
+ * Shared handle-GUID identification core (feat-20260713 M3 / w12 SSOT): given a
+ * schema `fieldType` and a `value`, invoke `sink(guidString, arrayIndex?)` for
+ * every GUID string the field binds — once for a `shared<T>` scalar string, once
+ * per string element of an `array<shared<T>>`. Non-shared fields, non-string
+ * scalars, and non-string array elements (already-resolved handle numbers, D-8)
+ * are skipped. Both the entity walk and the override walk route through here so
+ * the "is this a shared handle field + read its GUID" logic has one home
+ * (architecture-principles §1 SSOT).
+ */
+function forEachHandleGuid(
+  fieldType: string | undefined,
+  value: unknown,
+  sink: (guidString: string, arrayIndex?: number) => void,
+): void {
+  if (fieldType === undefined || typeof fieldType !== 'string') return;
+  if (fieldType.startsWith('shared<')) {
+    if (typeof value === 'string') sink(value);
+    return;
+  }
+  if (fieldType.startsWith('array<shared<') && Array.isArray(value)) {
+    for (let elemIdx = 0; elemIdx < value.length; elemIdx++) {
+      const elem = value[elemIdx];
+      if (typeof elem === 'string') sink(elem, elemIdx);
+    }
+  }
+}

package/src/scene-payload.ts

@@ -0,0 +1,207 @@
+// @forgeax/engine-assets-runtime -- scene payload parse + ref resolution
+// (feat-20260705-runtime-tier2-decomposition M1 / w4, D-4 F1 straight-cut).
+// Pure move from asset-registry.ts; zero identifier changes.
+
+import type {
+  LocalEntityId,
+  SceneAsset,
+  SceneEntity,
+  SceneInstanceMount,
+} from '@forgeax/engine-types';
+import { HANDLE_ARRAY_FIELD_NAMES, HANDLE_FIELD_NAMES } from './handles';
+
+/**
+ * Structured error returned by parseScenePayload when a refs index is
+ * out of bounds (F-2 / AC-02).
+ */
+interface ParseSceneError {
+  readonly localId: number;
+  readonly component: string;
+  readonly field: string;
+  readonly index: number;
+  readonly refsLength: number;
+}
+
+// Reconstruct a SceneAsset POD from a serialised pack payload (feat-20260514
+// w3 / parseAssetPayload 'scene' dispatch). The payload arrives as the
+// outer pack file's `assets[i].payload` object after ajv structural
+// validation; this helper re-stamps the LocalEntityId brand on each
+// SceneEntity.localId field and freezes the resulting POD shape so consumer
+// code sees the same readonly surface as a hand-authored SceneAsset (AC-01
+// + plan-strategy §3.1 rt_pkg sub-graph).
+//
+// feat-20260528-scene-asset-guid-refs-and-post-instantiate M1-fixup F-1:
+// refs parameter — when provided, integer values in handle-type component
+// fields (identified via HANDLE_FIELD_NAMES allowlist, plan-strategy D-4)
+// are replaced with refs[N] (GUID string). Non-handle integer fields
+// (Transform pos/quat/scale lanes, ChildOf.parent Entity, etc.)
+// are kept as-is.
+//
+// feat-20260528-scene-asset-guid-refs-and-post-instantiate M1-fixup F-2:
+// out-of-bounds (N < 0 or N >= refs.length) returns a structured
+// ParseSceneError with localId + component + field + index + refs.length
+// so the caller can construct a precise AssetError (AC-02).
+// The M1 stop-on-first-error (AC-08) behaviour is preserved.
+export function parseScenePayload(
+  payload: Record<string, unknown>,
+  refs?: string[],
+): SceneAsset | ParseSceneError | undefined {
+  const rawEntities = payload.entities;
+  if (!Array.isArray(rawEntities)) return undefined;
+  const nodes: SceneEntity[] = [];
+  for (const rn of rawEntities as Array<{ localId?: unknown; components?: unknown }>) {
+    if (typeof rn.localId !== 'number') return undefined;
+    const rawComponents = (rn.components ?? {}) as Record<string, Record<string, unknown>>;
+
+    // Resolve refs indices to GUID strings only for handle-type fields
+    // (plan-strategy D-4 / F-1 fix: non-handle integers preserved as-is).
+    if (refs) {
+      const resolvedComponents: Record<string, Record<string, unknown>> = {};
+      for (const compName of Object.keys(rawComponents)) {
+        const rawFields = rawComponents[compName];
+        if (!rawFields) continue;
+        const resolvedFields: Record<string, unknown> = {};
+        for (const fieldName of Object.keys(rawFields)) {
+          const value = rawFields[fieldName];
+          if (
+            HANDLE_FIELD_NAMES.has(fieldName) &&
+            typeof value === 'number' &&
+            Number.isInteger(value)
+          ) {
+            const idx = value;
+            if (idx < 0 || idx >= refs.length) {
+              return {
+                localId: rn.localId as number,
+                component: compName,
+                field: fieldName,
+                index: idx,
+                refsLength: refs.length,
+              };
+            }
+            resolvedFields[fieldName] = refs[idx];
+          } else if (HANDLE_ARRAY_FIELD_NAMES.has(fieldName) && Array.isArray(value)) {
+            // feat-20260608 M2 / w7: array<handle<X>> field — each element is a
+            // refs index resolved to a GUID string. Out-of-bounds in any element
+            // surfaces the same ParseSceneError as the scalar handle path.
+            const resolvedArr: string[] = [];
+            for (let elemIdx = 0; elemIdx < value.length; elemIdx++) {
+              const elem = value[elemIdx];
+              if (typeof elem !== 'number' || !Number.isInteger(elem)) {
+                resolvedFields[fieldName] = value;
+                resolvedArr.length = 0;
+                break;
+              }
+              if (elem < 0 || elem >= refs.length) {
+                return {
+                  localId: rn.localId as number,
+                  component: compName,
+                  field: `${fieldName}[${elemIdx}]`,
+                  index: elem,
+                  refsLength: refs.length,
+                };
+              }
+              const ref = refs[elem];
+              if (ref !== undefined) resolvedArr.push(ref);
+            }
+            if (resolvedArr.length === value.length) {
+              resolvedFields[fieldName] = resolvedArr;
+            } else if (resolvedFields[fieldName] === undefined) {
+              resolvedFields[fieldName] = value;
+            }
+          } else {
+            resolvedFields[fieldName] = value;
+          }
+        }
+        resolvedComponents[compName] = resolvedFields as Record<string, unknown>;
+      }
+      nodes.push({
+        localId: rn.localId as LocalEntityId,
+        components: resolvedComponents,
+      });
+    } else {
+      nodes.push({
+        localId: rn.localId as LocalEntityId,
+        components: rawComponents,
+      });
+    }
+  }
+  const resolvedMounts = resolveMounts(payload, refs);
+  if (resolvedMounts === undefined && Array.isArray(payload.mounts)) {
+    // mounts resolution failed (e.g. out-of-bounds source index)
+    return undefined;
+  }
+  // feat-20260612 M2 fixup: resolve `skinGuids` field (refs[] indices on disk
+  // -> GUID strings post-parse). The SkinAsset chain has no entity-component
+  // hook so the scene must carry an explicit cross-edge list; without it,
+  // browser-async-pack-fetch never loads SkinAssets and postSpawnResolveJoints
+  // silently skips, leaving Skin.joints.length=0 for every frame.
+  const resolvedSkinGuids = resolveSkinGuids(payload, refs);
+  if (resolvedSkinGuids === undefined && Array.isArray(payload.skinGuids)) {
+    return undefined;
+  }
+  return {
+    kind: 'scene',
+    entities: nodes,
+    mounts: resolvedMounts as unknown as readonly SceneInstanceMount[],
+    ...(resolvedSkinGuids !== undefined ? { skinGuids: resolvedSkinGuids } : {}),
+  } as SceneAsset;
+}
+
+/**
+ * feat-20260612 M2 fixup: resolve `SceneAsset.skinGuids` -- on-disk refs[]
+ * indices into post-parse GUID strings. Mirror of {@link resolveMounts}.
+ * Returns undefined when no `skinGuids` field is present (back-compat:
+ * pre-M2 SceneAssets carry no skin cross-edges).
+ */
+function resolveSkinGuids(
+  payload: Record<string, unknown>,
+  refs: readonly string[] | undefined,
+): readonly string[] | undefined {
+  const raw = payload.skinGuids;
+  if (!Array.isArray(raw)) return undefined;
+  const out: string[] = [];
+  for (const item of raw as ReadonlyArray<unknown>) {
+    if (typeof item === 'string') {
+      // Pre-resolved GUID string (in-memory dawn smoke / direct register path).
+      out.push(item);
+    } else if (typeof item === 'number' && Number.isInteger(item)) {
+      // refs[] index path (browser pack-fetch JSON-roundtrip shape).
+      if (refs === undefined) return undefined;
+      if (item < 0 || item >= refs.length) return undefined;
+      const guid = refs[item];
+      if (typeof guid !== 'string') return undefined;
+      out.push(guid);
+    } else {
+      return undefined;
+    }
+  }
+  return out;
+}
+
+/**
+ * Resolve mounts[].source integer indices through refs[] to GUID strings.
+ * Mount.source is resolved positionally (not through HANDLE_FIELD_NAMES),
+ * per AC-11. Returns undefined when no mounts field is present (back-compat).
+ */
+function resolveMounts(
+  payload: Record<string, unknown>,
+  refs: readonly string[] | undefined,
+): ReadonlyArray<Record<string, unknown>> | undefined {
+  const rawMounts = payload.mounts;
+  if (!Array.isArray(rawMounts)) return undefined;
+  if (refs === undefined) return rawMounts as ReadonlyArray<Record<string, unknown>>;
+  const resolved: Record<string, unknown>[] = [];
+  for (const rm of rawMounts as ReadonlyArray<Record<string, unknown>>) {
+    const mount = { ...rm };
+    const source = rm.source;
+    if (typeof source === 'number' && Number.isInteger(source)) {
+      const idx = source;
+      if (idx < 0 || idx >= refs.length) {
+        return undefined;
+      }
+      mount.source = refs[idx];
+    }
+    resolved.push(mount);
+  }
+  return resolved;
+}

package/src/wire-default-loaders.ts

@@ -0,0 +1,79 @@
+// @forgeax/engine-assets-runtime - wireDefaultLoaders + seed-table SSOT
+// (feat-20260603-asset-import-loader-injection M1 / w5 + w8; restructured by
+// feat-20260705-runtime-tier2-decomposition M1 / w8, D-2).
+//
+// wireDefaultLoaders is a one-line host helper that wires the engine's default
+// loader set onto a `LoaderRegistry`, mirroring the Console
+// `wireDefaultInspectors` shape (packages/console/src/wire-default-inspectors.ts;
+// research Finding 8). An AI user that has wired inspectors once recognises the
+// same form here at near-zero cost (requirements §AI User Affordances).
+//
+// The two seed tables INLINE_PACK_LOADERS + PACK_ARTIFACT_LOADERS are the
+// default set. videoLoader lives in graphics-extras and is wired here. The
+// complete ordinary Asset vocabulary is registered once at this boundary;
+// host-specific loaders may extend the table through `extraLoaders`.
+//
+// Default set wired internally: the 16 ordinary Asset kinds plus the existing
+// UI consumer loader. Host-only execution remains separate from descriptor load.
+//
+import { videoLoader } from '@forgeax/engine-graphics-extras';
+import type { Loader } from '@forgeax/engine-types';
+import { createUiLoader, type UiAsset } from '@forgeax/engine-ui';
+import { LoaderRegistry } from './loader-registry';
+import { INLINE_PACK_LOADERS } from './loaders/inline-pack';
+import { PACK_ARTIFACT_LOADERS } from './loaders/pack-artifact';
+
+const uiPayloadLoader = createUiLoader();
+const uiLoader: Loader<UiAsset> = {
+  kind: 'ui',
+  load: (payload) => {
+    const result = uiPayloadLoader.load(payload);
+    return result.ok ? result.value : undefined;
+  },
+};
+
+/**
+ * Wire the engine's default loader set (16 ordinary kinds plus UI) plus any
+ * `extraLoaders` onto `registry` in
+ * one call. Returns the same `registry` for chaining (so `wireDefaultLoaders(new
+ * LoaderRegistry())` is a one-expression wired registry). The `extraLoaders` are
+ * appended after the defaults and must use kinds outside the ordinary set.
+ *
+ * @example
+ * ```ts
+ * import { LoaderRegistry, wireDefaultLoaders } from '@forgeax/engine-assets-runtime';
+ * const loaders = wireDefaultLoaders(new LoaderRegistry());
+ * // loaders.get('mesh') / .get('texture') / .get('font') / .get('video') are
+ * // non-undefined; all ordinary Asset kinds share this same owner table.
+ * ```
+ */
+export function wireDefaultLoaders(
+  registry: LoaderRegistry,
+  extraLoaders: readonly Loader[] = [],
+): LoaderRegistry {
+  const extraKinds = new Set(extraLoaders.map((loader) => loader.kind));
+  const seeded = new Set<string>();
+  for (const loader of [...INLINE_PACK_LOADERS, ...PACK_ARTIFACT_LOADERS]) {
+    if (extraKinds.has(loader.kind)) continue;
+    if (seeded.has(loader.kind)) continue;
+    seeded.add(loader.kind);
+    registry.register(loader);
+  }
+  registry.register(videoLoader);
+  registry.register(uiLoader);
+  for (const loader of extraLoaders) registry.register(loader);
+  return registry;
+}
+
+/**
+ * Convenience factory: a fresh `LoaderRegistry` pre-wired with the default
+ * loader set (plus any `extraLoaders`). The production assembly point
+ * (`createRenderer`) and tests pass the result into `new LoaderRegistry()` (D-7
+ * constructor-injection; loaders always wired at construction -- used by
+ * `AssetRegistry` internally via `createDefaultLoaderRegistry(extraLoaders)` and
+ * by host code / tests independently) -- no setter / no illegal intermediate
+ * state).
+ */
+export function createDefaultLoaderRegistry(extraLoaders: readonly Loader[] = []): LoaderRegistry {
+  return wireDefaultLoaders(new LoaderRegistry(), extraLoaders);
+}

package/dist/__tests__/asset-graph-red.integration.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=asset-graph-red.integration.test.d.ts.map

package/dist/__tests__/asset-graph-red.integration.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"asset-graph-red.integration.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/asset-graph-red.integration.test.ts"],"names":[],"mappings":""}

package/dist/__tests__/asset-kind.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=asset-kind.test.d.ts.map

package/dist/__tests__/asset-kind.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"asset-kind.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/asset-kind.test.ts"],"names":[],"mappings":""}

package/dist/__tests__/asset-registry-core.integration.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=asset-registry-core.integration.test.d.ts.map

package/dist/__tests__/asset-registry-core.integration.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"asset-registry-core.integration.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/asset-registry-core.integration.test.ts"],"names":[],"mappings":""}

package/dist/__tests__/asset-registry-public-api.test-d.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=asset-registry-public-api.test-d.d.ts.map

package/dist/__tests__/asset-registry-public-api.test-d.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"asset-registry-public-api.test-d.d.ts","sourceRoot":"","sources":["../../src/__tests__/asset-registry-public-api.test-d.ts"],"names":[],"mappings":""}

package/dist/__tests__/asset-runtime-core-lifecycle.integration.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=asset-runtime-core-lifecycle.integration.test.d.ts.map

package/dist/__tests__/asset-runtime-core-lifecycle.integration.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"asset-runtime-core-lifecycle.integration.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/asset-runtime-core-lifecycle.integration.test.ts"],"names":[],"mappings":""}

package/dist/__tests__/asset-runtime-snapshot.unit.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=asset-runtime-snapshot.unit.test.d.ts.map

package/dist/__tests__/asset-runtime-snapshot.unit.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"asset-runtime-snapshot.unit.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/asset-runtime-snapshot.unit.test.ts"],"names":[],"mappings":""}

package/dist/__tests__/catalog-session-red.unit.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=catalog-session-red.unit.test.d.ts.map

package/dist/__tests__/catalog-session-red.unit.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"catalog-session-red.unit.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/catalog-session-red.unit.test.ts"],"names":[],"mappings":""}

package/dist/__tests__/registry-lifecycle-red.integration.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=registry-lifecycle-red.integration.test.d.ts.map

package/dist/__tests__/registry-lifecycle-red.integration.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"registry-lifecycle-red.integration.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/registry-lifecycle-red.integration.test.ts"],"names":[],"mappings":""}