@forgeax/engine-pack 0.1.20 → 0.1.23

package/dist/build.mjs

@@ -1,9 +1,10 @@
-import { ok, err, catalogOperationsFor, authoringCapabilityForAssetKind, PACK_ERROR_HINTS, MATERIAL_TEXTURE_SLOTS, projectCookProductEvidence, projectAssetEvidence, validateSourceOverrideMap, catalogEntryDigest, AssetError, ImportError } from '@forgeax/engine-types';
-import { join, dirname, resolve, isAbsolute, posix, relative, basename, extname } from 'path';
+import { ok, err, catalogOperationsFor, authoringCapabilityForAssetKind, MATERIAL_TEXTURE_SLOTS, projectCookProductEvidence, projectAssetEvidence, validateSourceOverrideMap, PACK_ERROR_HINTS, catalogEntryDigest, AssetError, ImportError } from '@forgeax/engine-types';
+import { dirname, resolve, isAbsolute, relative, join, basename, sep, extname } from 'path';
+import { sha1 } from '@noble/hashes/legacy.js';
 import { uuidv7obj } from 'uuidv7';
-import { readFileSync, existsSync } from 'fs';
 import { createHash } from 'crypto';
-import { stat, readFile, readdir, realpath, mkdtemp, rm } from 'fs/promises';
+import { stat, readFile, readdir, realpath, mkdir, writeFile, rename, rm, mkdtemp } from 'fs/promises';
+import { existsSync } from 'fs';
 import { tmpdir } from 'os';
 import { fileURLToPath } from 'url';
 import { Worker } from 'worker_threads';
@@ -1300,21 +1301,21 @@ var require_errors = __commonJS({
     function extendErrors({ gen, keyword, schemaValue, data, errsCount, it }) {
       if (errsCount === void 0)
         throw new Error("ajv implementation error");
-      const err6 = gen.name("err");
+      const err8 = gen.name("err");
       gen.forRange("i", errsCount, names_1.default.errors, (i) => {
-        gen.const(err6, (0, codegen_1._)`${names_1.default.vErrors}[${i}]`);
-        gen.if((0, codegen_1._)`${err6}.instancePath === undefined`, () => gen.assign((0, codegen_1._)`${err6}.instancePath`, (0, codegen_1.strConcat)(names_1.default.instancePath, it.errorPath)));
-        gen.assign((0, codegen_1._)`${err6}.schemaPath`, (0, codegen_1.str)`${it.errSchemaPath}/${keyword}`);
+        gen.const(err8, (0, codegen_1._)`${names_1.default.vErrors}[${i}]`);
+        gen.if((0, codegen_1._)`${err8}.instancePath === undefined`, () => gen.assign((0, codegen_1._)`${err8}.instancePath`, (0, codegen_1.strConcat)(names_1.default.instancePath, it.errorPath)));
+        gen.assign((0, codegen_1._)`${err8}.schemaPath`, (0, codegen_1.str)`${it.errSchemaPath}/${keyword}`);
         if (it.opts.verbose) {
-          gen.assign((0, codegen_1._)`${err6}.schema`, schemaValue);
-          gen.assign((0, codegen_1._)`${err6}.data`, data);
+          gen.assign((0, codegen_1._)`${err8}.schema`, schemaValue);
+          gen.assign((0, codegen_1._)`${err8}.data`, data);
         }
       });
     }
     exports.extendErrors = extendErrors;
     function addError(gen, errObj) {
-      const err6 = gen.const("err", errObj);
-      gen.if((0, codegen_1._)`${names_1.default.vErrors} === null`, () => gen.assign(names_1.default.vErrors, (0, codegen_1._)`[${err6}]`), (0, codegen_1._)`${names_1.default.vErrors}.push(${err6})`);
+      const err8 = gen.const("err", errObj);
+      gen.if((0, codegen_1._)`${names_1.default.vErrors} === null`, () => gen.assign(names_1.default.vErrors, (0, codegen_1._)`[${err8}]`), (0, codegen_1._)`${names_1.default.vErrors}.push(${err8})`);
       gen.code((0, codegen_1._)`${names_1.default.errors}++`);
     }
     function returnErrors(it, errs) {
@@ -2966,7 +2967,7 @@ var require_compile = __commonJS({
       const schOrFunc = root.refs[ref];
       if (schOrFunc)
         return schOrFunc;
-      let _sch = resolve3.call(this, root, ref);
+      let _sch = resolve4.call(this, root, ref);
       if (_sch === void 0) {
         const schema = (_a = root.localRefs) === null || _a === void 0 ? void 0 : _a[ref];
         const { schemaId } = this.opts;
@@ -2993,7 +2994,7 @@ var require_compile = __commonJS({
     function sameSchemaEnv(s1, s2) {
       return s1.schema === s2.schema && s1.root === s2.root && s1.baseId === s2.baseId;
     }
-    function resolve3(root, ref) {
+    function resolve4(root, ref) {
       let sch;
       while (typeof (sch = this.refs[ref]) == "string")
         ref = sch;
@@ -3621,7 +3622,7 @@ var require_fast_uri = __commonJS({
       }
       return uri;
     }
-    function resolve3(baseURI, relativeURI, options) {
+    function resolve4(baseURI, relativeURI, options) {
       const schemelessOptions = options ? Object.assign({ scheme: "null" }, options) : { scheme: "null" };
       const resolved = resolveComponent(parse(baseURI, schemelessOptions), parse(relativeURI, schemelessOptions), schemelessOptions, true);
       schemelessOptions.skipEscape = true;
@@ -3879,7 +3880,7 @@ var require_fast_uri = __commonJS({
     var fastUri = {
       SCHEMES,
       normalize,
-      resolve: resolve3,
+      resolve: resolve4,
       resolveComponent,
       equal,
       serialize,
@@ -4716,8 +4717,8 @@ var require_multipleOf = __commonJS({
         const { gen, data, schemaCode, it } = cxt;
         const prec = it.opts.multipleOfPrecision;
         const res = gen.let("res");
-        const invalid3 = prec ? (0, codegen_1._)`Math.abs(Math.round(${res}) - ${res}) > 1e-${prec}` : (0, codegen_1._)`${res} !== parseInt(${res})`;
-        cxt.fail$data((0, codegen_1._)`(${schemaCode} === 0 || (${res} = ${data}/${schemaCode}, ${invalid3}))`);
+        const invalid2 = prec ? (0, codegen_1._)`Math.abs(Math.round(${res}) - ${res}) > 1e-${prec}` : (0, codegen_1._)`${res} !== parseInt(${res})`;
+        cxt.fail$data((0, codegen_1._)`(${schemaCode} === 0 || (${res} = ${data}/${schemaCode}, ${invalid2}))`);
       }
     };
     exports.default = def;
@@ -6895,6 +6896,10 @@ function bytesToDashForm(bytes) {
   return `${h[bytes[0]]}${h[bytes[1]]}${h[bytes[2]]}${h[bytes[3]]}-${h[bytes[4]]}${h[bytes[5]]}-${h[bytes[6]]}${h[bytes[7]]}-${h[bytes[8]]}${h[bytes[9]]}-${h[bytes[10]]}${h[bytes[11]]}${h[bytes[12]]}${h[bytes[13]]}${h[bytes[14]]}${h[bytes[15]]}`;
 }
 var UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+var PACK_SOURCE_KEY_RE = /^[a-z0-9][a-z0-9._-]*(\/[a-z0-9][a-z0-9._-]*)*$/;
+function isValidPackSourceKey(value) {
+  return typeof value === "string" && PACK_SOURCE_KEY_RE.test(value);
+}
 function isValidAssetGuidString(value) {
   return typeof value === "string" && UUID_RE.test(value);
 }
@@ -6906,6 +6911,48 @@ function dashFormToBytes(dashForm) {
   }
   return bytes;
 }
+function randomUuidBytes() {
+  const uuid = uuidv7obj();
+  const bytes = new Uint8Array(16);
+  bytes.set(uuid.bytes);
+  return bytes;
+}
+function packageId(value) {
+  return value;
+}
+var PackageId = {
+  parse(dashForm) {
+    const parsed = AssetGuid.parse(dashForm);
+    return parsed.ok ? { ok: true, value: packageId(parsed.value) } : parsed;
+  },
+  format(value) {
+    return bytesToDashForm(value);
+  },
+  random() {
+    return packageId(randomUuidBytes());
+  }
+};
+function derivedGuid(namespace, sourceKey2) {
+  if (!(namespace instanceof Uint8Array) || namespace.byteLength !== 16) {
+    throw new TypeError("AssetGuid.derive requires a 16-byte PackageId");
+  }
+  if (!isValidPackSourceKey(sourceKey2)) {
+    const error = new TypeError(
+      `AssetGuid.derive received invalid sourceKey ${JSON.stringify(sourceKey2)}`
+    );
+    Object.defineProperty(error, "code", { value: "pack-source-key-invalid" });
+    throw error;
+  }
+  const name = new TextEncoder().encode(sourceKey2);
+  const input = new Uint8Array(namespace.byteLength + name.byteLength);
+  input.set(namespace, 0);
+  input.set(name, namespace.byteLength);
+  const digest3 = sha1(input);
+  const result = digest3.slice(0, 16);
+  result[6] = (result[6] ?? 0) & 15 | 80;
+  result[8] = (result[8] ?? 0) & 63 | 128;
+  return brand(result);
+}
 var AssetGuid = {
   /**
    * Parse a 36-char RFC 4122 dash-form UUID string into an AssetGuid.
@@ -6949,507 +6996,1075 @@ var AssetGuid = {
    * Works in both Node.js and browser environments.
    */
   random() {
-    const uuid = uuidv7obj();
-    const bytes = new Uint8Array(16);
-    bytes.set(uuid.bytes);
-    return brand(bytes);
+    return brand(randomUuidBytes());
+  },
+  /** Derive the stable UUIDv5 projection for one Pack subject and sourceKey. */
+  derive(namespace, sourceKey2) {
+    return derivedGuid(namespace, sourceKey2);
   }
 };
-
-// src/scriptable-pack.ts
-var SCRIPTABLE_PACK_ASSET_KINDS = [
-  "mesh",
-  "material",
-  "scene",
-  "texture",
-  "equirect",
-  "sampler",
-  "font",
-  "render-pipeline",
-  "tileset",
-  "video",
-  "skeleton",
-  "skin",
-  "animation-clip",
-  "animation-graph",
-  "audio",
-  "particle-effect"
+var PACK_PARAMETER_TYPES = [
+  "bool",
+  "u32",
+  "i32",
+  "f32",
+  "f64",
+  "string",
+  "enum",
+  "vec2",
+  "vec3",
+  "vec4",
+  "color",
+  "asset-guid"
 ];
-var SCRIPTABLE_PACK_CAPABILITY_MANIFEST = {
-  assetKinds: SCRIPTABLE_PACK_ASSET_KINDS,
-  durablePayload: true,
-  refs: true,
-  artifacts: true,
-  hostCapabilities: ["audio-install", "video-play", "particle-execute"]
-};
-function isScriptablePackAssetKind(value) {
-  return SCRIPTABLE_PACK_ASSET_KINDS.includes(value);
-}
-function sceneComponentFieldType(value) {
-  if (typeof value === "string") return value;
-  if (isRecord(value) && typeof value.type === "string") return value.type;
-  return void 0;
-}
-function projectScriptablePackSceneComponents(components) {
-  return (components ?? []).map((component) => ({
-    name: component.name,
-    fields: Object.fromEntries(
-      Object.entries(component.fields).map(([fieldName, field]) => [
-        fieldName,
-        sceneComponentFieldType(field)
-      ])
-    )
-  }));
-}
-var SCRIPTABLE_PACK_REQUEST_ID_SCHEMA = {
-  type: "string",
-  minLength: 1,
-  maxLength: 128,
-  pattern: "^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$",
-  description: "Caller-minted identity for one idempotent ScriptablePack operation."
-};
-var SCRIPTABLE_PACK_SOURCE_PATH_SCHEMA = {
-  type: "string",
-  minLength: 8,
-  pattern: "^[^/].*\\.pack\\.ts$",
-  description: "Game-root-relative ScriptablePack source path."
-};
-var SCRIPTABLE_PACK_OWNER_GUID_SCHEMA = {
-  type: "string",
-  format: "uuid",
-  description: "Catalog GUID used to resolve the producer-owned source subject."
-};
-var SCRIPTABLE_PACK_REVISION_SCHEMA = {
-  type: "string",
-  minLength: 64,
-  maxLength: 64,
-  pattern: "^[a-f0-9]{64}$",
-  description: "SHA-256 source revision returned by preflight."
-};
-var SCRIPTABLE_PACK_SOURCE_KEY_SCHEMA = { type: "string", minLength: 1 };
-var SCRIPTABLE_PACK_ASSET_KIND_SCHEMA = {
-  enum: SCRIPTABLE_PACK_ASSET_KINDS,
-  description: "Ordinary Asset kind supported by the ScriptablePack producer/loader matrix."
-};
-var SCRIPTABLE_PACK_NAME_SCHEMA = { type: "string", minLength: 1 };
-function scriptablePackArgsSchema(properties, required, options = {}) {
-  const subjectRequired = ["requestId", ...required];
+function authoringError(code, expected, hint, detail = {}, actual) {
   return {
-    type: "object",
-    properties: {
-      sourcePath: SCRIPTABLE_PACK_SOURCE_PATH_SCHEMA,
-      ownerGuid: SCRIPTABLE_PACK_OWNER_GUID_SCHEMA,
-      requestId: SCRIPTABLE_PACK_REQUEST_ID_SCHEMA,
-      ...properties
-    },
-    required: subjectRequired,
-    ...options.subject === false ? {} : {
-      anyOf: [
-        { required: [...subjectRequired, "sourcePath"] },
-        { required: [...subjectRequired, "ownerGuid"] },
-        ...options.guidSubject === false ? [] : [{ required: [...subjectRequired, "guid"] }]
-      ]
-    },
-    additionalProperties: false
+    code,
+    expected,
+    hint,
+    ...actual === void 0 ? {} : { actual },
+    detail
   };
 }
-[
-  {
-    id: "asset-source.create",
-    kind: "create",
-    domain: "session",
-    title: "Create Asset Source",
-    argsSchema: scriptablePackArgsSchema(
-      {
-        name: SCRIPTABLE_PACK_NAME_SCHEMA,
-        initialOutput: {
-          type: "object",
-          properties: {
-            sourceKey: SCRIPTABLE_PACK_SOURCE_KEY_SCHEMA,
-            kind: SCRIPTABLE_PACK_ASSET_KIND_SCHEMA,
-            name: SCRIPTABLE_PACK_NAME_SCHEMA
-          },
-          required: ["sourceKey", "kind"],
-          additionalProperties: false
-        }
-      },
-      ["sourcePath", "initialOutput"],
-      { subject: false }
-    )
-  },
-  {
-    id: "asset-source.add-output",
-    kind: "add-output",
-    domain: "session",
-    title: "Add Asset Source Output",
-    argsSchema: scriptablePackArgsSchema(
-      {
-        sourceKey: SCRIPTABLE_PACK_SOURCE_KEY_SCHEMA,
-        assetKind: SCRIPTABLE_PACK_ASSET_KIND_SCHEMA,
-        name: SCRIPTABLE_PACK_NAME_SCHEMA,
-        expectedRevision: SCRIPTABLE_PACK_REVISION_SCHEMA
-      },
-      ["sourceKey", "assetKind", "expectedRevision"]
-    )
-  },
-  {
-    id: "asset-source.add-external-asset",
-    kind: "add-external-asset",
-    domain: "session",
-    title: "Add Asset Source External Asset",
-    argsSchema: scriptablePackArgsSchema(
-      {
-        alias: SCRIPTABLE_PACK_SOURCE_KEY_SCHEMA,
-        guid: { type: "string", format: "uuid" },
-        expectedRevision: SCRIPTABLE_PACK_REVISION_SCHEMA
-      },
-      ["alias", "guid", "expectedRevision"],
-      { guidSubject: false }
-    )
-  },
-  {
-    id: "asset-source.rename",
-    kind: "rename",
-    domain: "session",
-    title: "Rename Asset Source Display Name",
-    argsSchema: scriptablePackArgsSchema(
-      {
-        target: {
-          oneOf: [
-            {
-              type: "object",
-              properties: { kind: { const: "package" } },
-              required: ["kind"],
-              additionalProperties: false
-            },
-            {
-              type: "object",
-              properties: {
-                kind: { const: "output" },
-                sourceKey: SCRIPTABLE_PACK_SOURCE_KEY_SCHEMA
-              },
-              required: ["kind", "sourceKey"],
-              additionalProperties: false
-            }
-          ]
-        },
-        name: SCRIPTABLE_PACK_NAME_SCHEMA,
-        expectedRevision: SCRIPTABLE_PACK_REVISION_SCHEMA
-      },
-      ["target", "name", "expectedRevision"]
-    )
-  },
-  {
-    id: "asset-source.remove-output",
-    kind: "remove-output",
-    domain: "session",
-    title: "Remove Asset Source Output",
-    destructive: true,
-    argsSchema: scriptablePackArgsSchema(
-      {
-        sourceKey: SCRIPTABLE_PACK_SOURCE_KEY_SCHEMA,
-        confirmIncomingRefs: { type: "array", items: { type: "string" } },
-        expectedRevision: SCRIPTABLE_PACK_REVISION_SCHEMA
-      },
-      ["sourceKey", "expectedRevision"]
-    )
-  },
-  {
-    id: "asset-source.clone",
-    kind: "clone",
-    domain: "session",
-    title: "Clone Asset Source",
-    argsSchema: scriptablePackArgsSchema(
-      {
-        targetPath: SCRIPTABLE_PACK_SOURCE_PATH_SCHEMA,
-        expectedRevision: SCRIPTABLE_PACK_REVISION_SCHEMA
-      },
-      ["targetPath", "expectedRevision"]
-    )
-  },
-  {
-    id: "asset-source.rebuild",
-    kind: "rebuild",
-    domain: "session",
-    title: "Rebuild Asset Source",
-    argsSchema: scriptablePackArgsSchema({ expectedRevision: SCRIPTABLE_PACK_REVISION_SCHEMA }, [
-      "expectedRevision"
-    ])
-  },
-  {
-    id: "asset-source.cold-cook",
-    kind: "cold-cook",
-    domain: "session",
-    title: "Cold Cook Asset Source",
-    argsSchema: scriptablePackArgsSchema({ expectedRevision: SCRIPTABLE_PACK_REVISION_SCHEMA }, [
-      "expectedRevision"
-    ])
-  }
-];
-function actual(value) {
-  if (value === null) return "null";
-  if (Array.isArray(value)) return "array";
-  if (ArrayBuffer.isView(value)) return value.constructor.name;
-  return typeof value;
-}
-function invalid(propertyPath, expected, value, sourcePath) {
-  return err({
-    code: "pack-source-definition-invalid",
-    expected,
-    hint: "repair the default exported ScriptablePack definition, then inspect Meta again",
-    detail: {
-      ...sourcePath === void 0 ? {} : { sourcePath },
-      propertyPath,
-      actual: actual(value)
-    }
-  });
+function failure(error) {
+  return err(error);
 }
 function isRecord(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
-function isAssetGuid(value) {
+function validateSceneComponents(value) {
+  if (value === void 0) return ok(void 0);
+  if (!Array.isArray(value)) {
+    return failure(
+      parameterFailure(
+        "$.sceneComponents",
+        "an array of component schema records",
+        value,
+        "sceneComponents is not an array"
+      )
+    );
+  }
+  const components = [];
+  const names = /* @__PURE__ */ new Set();
+  for (const [componentIndex, candidate] of value.entries()) {
+    if (!isRecord(candidate) || typeof candidate.name !== "string" || !isRecord(candidate.fields)) {
+      return failure(
+        parameterFailure(
+          `$.sceneComponents[${componentIndex}]`,
+          "a component record with name and fields",
+          candidate,
+          "scene component schema is malformed"
+        )
+      );
+    }
+    if (candidate.name.length === 0 || names.has(candidate.name)) {
+      return failure(
+        parameterFailure(
+          `$.sceneComponents[${componentIndex}].name`,
+          "a non-empty unique component name",
+          candidate.name,
+          "scene component names must be unique"
+        )
+      );
+    }
+    names.add(candidate.name);
+    const fields = {};
+    for (const [fieldName, field] of Object.entries(candidate.fields)) {
+      if (typeof field === "string" && field.length === 0 || typeof field !== "string" && (!isRecord(field) || typeof field.type !== "string" || field.type.length === 0)) {
+        return failure(
+          parameterFailure(
+            `$.sceneComponents[${componentIndex}].fields.${fieldName}`,
+            "a field type string or { type: string }",
+            field,
+            "scene component field schema is malformed"
+          )
+        );
+      }
+      fields[fieldName] = field;
+    }
+    components.push({ name: candidate.name, fields });
+  }
+  return ok(components);
+}
+function isPackageId(value) {
   return value instanceof Uint8Array && value.byteLength === 16;
 }
-function guidKey(guid) {
-  return AssetGuid.format(guid);
+function cloneValue(value) {
+  if (value instanceof Uint8Array) return value.slice();
+  if (Array.isArray(value)) return value.map((item) => cloneValue(item));
+  return value;
 }
-function freezeDefinition(definition) {
-  const assets = Object.fromEntries(
-    Object.entries(definition.assets).map(([sourceKey2, descriptor]) => [
-      sourceKey2,
-      Object.freeze({ ...descriptor, guid: descriptor.guid.slice() })
-    ])
-  );
-  const externalAssets = Object.fromEntries(
-    Object.entries(definition.externalAssets).map(([alias, guid]) => [
-      alias,
-      guid.slice()
-    ])
+function sourceKeyFailure(sourceKey2, propertyPath = "$.sourceKey") {
+  return authoringError(
+    "pack-source-key-invalid",
+    "a sourceKey matching ^[a-z0-9][a-z0-9._-]*(/[a-z0-9][a-z0-9._-]*)*$",
+    "use a stable lower-case semantic key; do not derive it from file paths or output order",
+    { propertyPath, sourceKey: sourceKey2 },
+    typeof sourceKey2 === "string" ? sourceKey2 : void 0
   );
-  const sceneComponents = definition.sceneComponents === void 0 ? void 0 : Object.freeze(
-    projectScriptablePackSceneComponents(definition.sceneComponents).map(
-      (component) => Object.freeze({
-        ...component,
-        fields: Object.freeze({ ...component.fields })
-      })
-    )
+}
+function parameterFailure(propertyPath, expected, actual, reason) {
+  return authoringError(
+    "pack-parameter-invalid",
+    expected,
+    "repair the parameter declaration or the instance values, then inspect and rebuild",
+    { propertyPath, reason, actual: typeof actual === "string" ? actual : JSON.stringify(actual) }
   );
-  return Object.freeze({
-    ...definition,
-    packageId: definition.packageId.slice(),
-    assets: Object.freeze(assets),
-    externalAssets: Object.freeze(externalAssets),
-    ...sceneComponents === void 0 ? {} : { sceneComponents }
-  });
 }
-function validateScriptablePackDefinition(value, sourcePath) {
-  if (!isRecord(value))
-    return invalid("$", "a ScriptablePack definition object", value, sourcePath);
-  if (value.schemaVersion !== "1.0.0") {
-    return invalid("$.schemaVersion", "the literal '1.0.0'", value.schemaVersion, sourcePath);
+function numericType(type) {
+  return type === "u32" || type === "i32" || type === "f32" || type === "f64";
+}
+function vectorLength(type) {
+  switch (type) {
+    case "vec2":
+      return 2;
+    case "vec3":
+      return 3;
+    case "vec4":
+    case "color":
+      return 4;
+    default:
+      return void 0;
   }
-  if (!isAssetGuid(value.packageId)) {
-    return invalid("$.packageId", "a 16-byte AssetGuid", value.packageId, sourcePath);
+}
+function parameterValueError(parameter, value, propertyPath) {
+  const { type } = parameter;
+  if (type === "bool" && typeof value !== "boolean") {
+    return parameterFailure(propertyPath, "a boolean", value, "bool value has the wrong type");
+  }
+  if (numericType(type)) {
+    if (typeof value !== "number" || !Number.isFinite(value)) {
+      return parameterFailure(
+        propertyPath,
+        "a finite number",
+        value,
+        "numeric value is not finite"
+      );
+    }
+    if ((type === "u32" || type === "i32") && !Number.isInteger(value)) {
+      return parameterFailure(
+        propertyPath,
+        "an integer",
+        value,
+        "integer parameter received a fraction"
+      );
+    }
+    if (type === "u32" && (value < 0 || value > 4294967295)) {
+      return parameterFailure(
+        propertyPath,
+        "an unsigned 32-bit integer",
+        value,
+        "u32 value is outside [0, 2^32 - 1]"
+      );
+    }
+    if (type === "i32" && (value < -2147483648 || value > 2147483647)) {
+      return parameterFailure(
+        propertyPath,
+        "a signed 32-bit integer",
+        value,
+        "i32 value is outside [-2^31, 2^31 - 1]"
+      );
+    }
+    if (type === "f32" && !Number.isFinite(Math.fround(value))) {
+      return parameterFailure(
+        propertyPath,
+        "a finite IEEE-754 32-bit float",
+        value,
+        "f32 value overflows binary32"
+      );
+    }
+    if (parameter.minimum !== void 0 && value < parameter.minimum) {
+      return parameterFailure(
+        propertyPath,
+        `a number >= ${parameter.minimum}`,
+        value,
+        "value is below minimum"
+      );
+    }
+    if (parameter.maximum !== void 0 && value > parameter.maximum) {
+      return parameterFailure(
+        propertyPath,
+        `a number <= ${parameter.maximum}`,
+        value,
+        "value is above maximum"
+      );
+    }
+    return void 0;
   }
-  if (value.name !== void 0 && typeof value.name !== "string") {
-    return invalid("$.name", "a string when present", value.name, sourcePath);
-  }
-  if (!isRecord(value.assets) || Object.keys(value.assets).length === 0) {
-    return invalid(
-      "$.assets",
-      "a non-empty sourceKey to descriptor object",
-      value.assets,
-      sourcePath
-    );
+  if (type === "string" && typeof value !== "string") {
+    return parameterFailure(propertyPath, "a string", value, "string parameter has the wrong type");
   }
-  if (!isRecord(value.externalAssets)) {
-    return invalid(
-      "$.externalAssets",
-      "an alias to AssetGuid object",
-      value.externalAssets,
-      sourcePath
-    );
+  if (type === "enum") {
+    if (typeof value !== "string") {
+      return parameterFailure(
+        propertyPath,
+        "one of the declared enum strings",
+        value,
+        "enum value has the wrong type"
+      );
+    }
+    if (parameter.values === void 0 || !parameter.values.includes(value)) {
+      return parameterFailure(
+        propertyPath,
+        "one of the declared enum values",
+        value,
+        "enum value is not declared"
+      );
+    }
+    return void 0;
   }
-  if (value.sceneComponents !== void 0) {
-    if (!Array.isArray(value.sceneComponents)) {
-      return invalid(
-        "$.sceneComponents",
-        "an array of component tokens or neutral schema rows when present",
-        value.sceneComponents,
-        sourcePath
+  const length = vectorLength(type);
+  if (length !== void 0) {
+    if (!Array.isArray(value) || value.length !== length || value.some((component) => typeof component !== "number" || !Number.isFinite(component))) {
+      return parameterFailure(
+        propertyPath,
+        `a finite numeric vector with ${length} components`,
+        value,
+        "vector value has the wrong shape"
       );
     }
-    const componentNames = /* @__PURE__ */ new Set();
-    for (const [componentIndex, component] of value.sceneComponents.entries()) {
-      if (!isRecord(component)) {
-        return invalid(
-          `$.sceneComponents[${componentIndex}]`,
-          "a component token or neutral schema row",
-          component,
-          sourcePath
-        );
-      }
-      if (typeof component.name !== "string" || component.name.trim().length === 0) {
-        return invalid(
-          `$.sceneComponents[${componentIndex}].name`,
-          "a non-empty component name",
-          component.name,
-          sourcePath
-        );
-      }
-      if (componentNames.has(component.name)) {
-        return invalid(
-          `$.sceneComponents[${componentIndex}].name`,
-          "component names to be unique within one ScriptablePack",
-          component.name,
-          sourcePath
-        );
-      }
-      componentNames.add(component.name);
-      if (!isRecord(component.fields)) {
-        return invalid(
-          `$.sceneComponents[${componentIndex}].fields`,
-          "a field-name to schema-type object",
-          component.fields,
-          sourcePath
-        );
-      }
-      for (const [fieldName, field] of Object.entries(component.fields)) {
-        const type = sceneComponentFieldType(field);
-        if (fieldName.trim().length === 0 || type === void 0 || type.trim().length === 0) {
-          return invalid(
-            `$.sceneComponents[${componentIndex}].fields`,
-            "field names with non-empty string schema types",
-            field,
-            sourcePath
-          );
-        }
-      }
+    if (type === "color" && value.some((component) => component < 0 || component > 1)) {
+      return parameterFailure(
+        propertyPath,
+        "an RGBA color with components in [0, 1]",
+        value,
+        "color component is outside [0, 1]"
+      );
     }
+    return void 0;
   }
-  if (typeof value.build !== "function") {
-    return invalid("$.build", "a build(assetReader) function", value.build, sourcePath);
-  }
-  const packageGuid = guidKey(value.packageId);
-  const localGuids = /* @__PURE__ */ new Set();
-  for (const [sourceKey2, descriptor] of Object.entries(value.assets)) {
-    if (sourceKey2.trim().length === 0) {
-      return invalid("$.assets", "non-empty sourceKey object keys", sourceKey2, sourcePath);
-    }
-    if (!isRecord(descriptor)) {
-      return invalid(
-        `$.assets[${JSON.stringify(sourceKey2)}]`,
-        "an asset descriptor",
-        descriptor,
-        sourcePath
+  if (type === "asset-guid") {
+    const validString = typeof value === "string" && isValidAssetGuidString(value);
+    if (!(value instanceof Uint8Array && value.byteLength === 16) && !validString) {
+      return parameterFailure(
+        propertyPath,
+        "a 16-byte AssetGuid or UUID string",
+        value,
+        "asset GUID value is malformed"
+      );
+    }
+    return void 0;
+  }
+  return parameterFailure(
+    propertyPath,
+    "a supported Pack parameter type",
+    value,
+    "unknown parameter type"
+  );
+}
+function normalizeParameterValue(parameter, value, propertyPath) {
+  const error = parameterValueError(parameter, value, propertyPath);
+  if (error !== void 0) return failure(error);
+  if (parameter.type === "asset-guid" && typeof value === "string") {
+    const parsed = AssetGuid.parse(value);
+    if (!parsed.ok) {
+      return failure(
+        parameterFailure(
+          propertyPath,
+          "a valid AssetGuid UUID string",
+          value,
+          "asset GUID parser rejected the value"
+        )
       );
     }
-    if (!isAssetGuid(descriptor.guid)) {
-      return invalid(
-        `$.assets[${JSON.stringify(sourceKey2)}].guid`,
-        "a 16-byte AssetGuid",
-        descriptor.guid,
-        sourcePath
+    return ok(parsed.value);
+  }
+  return ok(cloneValue(value));
+}
+function validateParameterDefinitions(parameters, propertyPath = "$.parameters") {
+  if (!Array.isArray(parameters) || parameters.length === 0) {
+    return failure(
+      parameterFailure(
+        propertyPath,
+        "a non-empty parameter descriptor array",
+        parameters,
+        "parameters must be explicit and non-empty"
+      )
+    );
+  }
+  const names = /* @__PURE__ */ new Set();
+  const normalized = [];
+  for (const [index, candidate] of parameters.entries()) {
+    const path = `${propertyPath}[${index}]`;
+    if (!isRecord(candidate))
+      return failure(
+        parameterFailure(
+          path,
+          "a parameter descriptor object",
+          candidate,
+          "descriptor is not an object"
+        )
+      );
+    const name = candidate.name;
+    if (typeof name !== "string" || !/^[A-Za-z][A-Za-z0-9_.-]*$/.test(name)) {
+      return failure(
+        parameterFailure(
+          `${path}.name`,
+          "a unique identifier-like parameter name",
+          name,
+          "parameter name is invalid"
+        )
       );
     }
-    if (typeof descriptor.kind !== "string" || !isScriptablePackAssetKind(descriptor.kind)) {
-      return invalid(
-        `$.assets[${JSON.stringify(sourceKey2)}].kind`,
-        "one of SCRIPTABLE_PACK_ASSET_KINDS",
-        descriptor.kind,
-        sourcePath
+    if (names.has(name))
+      return failure(
+        parameterFailure(
+          `${path}.name`,
+          "a unique parameter name",
+          name,
+          "parameter name is duplicated"
+        )
+      );
+    names.add(name);
+    const unknown = Object.keys(candidate).find(
+      (key) => !["name", "type", "default", "minimum", "maximum", "values", "kind"].includes(key)
+    );
+    if (unknown !== void 0) {
+      return failure(
+        parameterFailure(
+          `${path}.${unknown}`,
+          "only name, type, default, minimum, maximum, values, and kind fields",
+          candidate[unknown],
+          "parameter descriptors are a closed authoring schema"
+        )
+      );
+    }
+    const type = candidate.type;
+    if (typeof type !== "string" || !PACK_PARAMETER_TYPES.includes(type)) {
+      return failure(
+        parameterFailure(
+          `${path}.type`,
+          PACK_PARAMETER_TYPES.join(" | "),
+          type,
+          "parameter type is not supported"
+        )
       );
     }
-    if (descriptor.name !== void 0 && typeof descriptor.name !== "string") {
-      return invalid(
-        `$.assets[${JSON.stringify(sourceKey2)}].name`,
-        "a string when present",
-        descriptor.name,
-        sourcePath
+    const typed = {
+      ...candidate,
+      name,
+      type
+    };
+    if (typed.values !== void 0) {
+      if (typed.type !== "enum" || !Array.isArray(typed.values) || typed.values.length === 0 || typed.values.some((item) => typeof item !== "string") || new Set(typed.values).size !== typed.values.length) {
+        return failure(
+          parameterFailure(
+            `${path}.values`,
+            "unique non-empty strings for enum",
+            typed.values,
+            "enum values are malformed"
+          )
+        );
+      }
+    } else if (typed.type === "enum") {
+      return failure(
+        parameterFailure(
+          `${path}.values`,
+          "a non-empty enum choices array",
+          typed.values,
+          "enum has no choices"
+        )
       );
     }
-    const guid = guidKey(descriptor.guid);
-    if (guid === packageGuid || localGuids.has(guid)) {
-      return invalid(
-        `$.assets[${JSON.stringify(sourceKey2)}].guid`,
-        "a GUID unique within the package and distinct from packageId",
-        descriptor.guid,
-        sourcePath
+    if (typed.kind !== void 0 && (typed.type !== "asset-guid" || typeof typed.kind !== "string")) {
+      return failure(
+        parameterFailure(
+          `${path}.kind`,
+          "a kind constraint only on asset-guid parameters",
+          typed.kind,
+          "kind is misplaced"
+        )
       );
     }
-    localGuids.add(guid);
-  }
-  const externalGuids = /* @__PURE__ */ new Set();
-  for (const [alias, guidValue] of Object.entries(value.externalAssets)) {
-    if (alias.trim().length === 0) {
-      return invalid("$.externalAssets", "non-empty alias object keys", alias, sourcePath);
+    for (const field of ["minimum", "maximum"]) {
+      const bound = typed[field];
+      if (bound !== void 0 && (typeof bound !== "number" || !Number.isFinite(bound))) {
+        return failure(
+          parameterFailure(
+            `${path}.${field}`,
+            "a finite numeric bound",
+            bound,
+            "numeric bound is invalid"
+          )
+        );
+      }
     }
-    if (!isAssetGuid(guidValue)) {
-      return invalid(
-        `$.externalAssets[${JSON.stringify(alias)}]`,
-        "a 16-byte AssetGuid",
-        guidValue,
-        sourcePath
+    if (!numericType(typed.type) && (typed.minimum !== void 0 || typed.maximum !== void 0)) {
+      return failure(
+        parameterFailure(
+          path,
+          "minimum/maximum only on numeric parameters",
+          typed,
+          "numeric bounds are not meaningful for this parameter type"
+        )
       );
     }
-    const guid = guidKey(guidValue);
-    if (guid === packageGuid || localGuids.has(guid) || externalGuids.has(guid)) {
-      return invalid(
-        `$.externalAssets[${JSON.stringify(alias)}]`,
-        "a unique foreign GUID not owned by this package",
-        guidValue,
-        sourcePath
+    if (typed.minimum !== void 0 && typed.maximum !== void 0 && typed.minimum > typed.maximum) {
+      return failure(
+        parameterFailure(path, "minimum <= maximum", typed, "numeric bounds are reversed")
       );
     }
-    externalGuids.add(guid);
+    const defaultResult = normalizeParameterValue(typed, typed.default, `${path}.default`);
+    if (!defaultResult.ok) return defaultResult;
+    normalized.push({
+      ...typed,
+      default: defaultResult.value,
+      ...typed.values === void 0 ? {} : { values: Object.freeze([...typed.values]) }
+    });
   }
-  return ok(freezeDefinition(value));
+  return ok(Object.freeze(normalized));
 }
-function projectScriptablePackMeta(definition, source) {
-  const subAssets = Object.entries(definition.assets).sort(([left], [right]) => left.localeCompare(right)).map(([sourceKey2, descriptor], sourceIndex) => ({
-    guid: guidKey(descriptor.guid),
-    sourceIndex,
-    sourceKey: sourceKey2,
-    kind: descriptor.kind,
-    ...descriptor.name === void 0 ? {} : { name: descriptor.name }
-  }));
-  const externalAssets = Object.entries(definition.externalAssets).sort(([left], [right]) => left.localeCompare(right)).map(([alias, guid]) => ({ alias, guid: guidKey(guid) }));
-  return {
-    schemaVersion: "1.0.0",
-    kind: "external-asset-package",
-    packageId: guidKey(definition.packageId),
-    ...definition.name === void 0 ? {} : { name: definition.name },
-    importer: "pack-ts",
-    source,
-    importSettings: { contractVersion: "1.0.0", externalAssets },
-    subAssets
-  };
+function definePackageId(value) {
+  if (isPackageId(value)) return value.slice();
+  const parsed = PackageId.parse(value);
+  if (!parsed.ok) {
+    const error = authoringError(
+      "pack-package-id-invalid",
+      "a 36-character RFC 4122 UUID packageId",
+      "use PackageId.random() or repair the packageId literal before loading the Pack",
+      { value },
+      value
+    );
+    throw Object.assign(new TypeError(error.hint), error);
+  }
+  return parsed.value;
 }
-
-// src/catalog-projection.ts
-function catalogProjectionFor(subject, execution, lifecycle) {
+function cloneDefinition(definition) {
+  const parameters = "parameters" in definition ? Object.freeze(
+    definition.parameters.map(
+      (parameter) => Object.freeze({
+        ...parameter,
+        default: cloneValue(parameter.default),
+        ...parameter.values === void 0 ? {} : { values: Object.freeze(parameter.values.map((value) => cloneValue(value))) }
+      })
+    )
+  ) : void 0;
+  const sceneComponents = definition.sceneComponents === void 0 ? void 0 : Object.freeze(
+    definition.sceneComponents.map(
+      (component) => Object.freeze({
+        name: component.name,
+        fields: Object.freeze({ ...component.fields })
+      })
+    )
+  );
+  return Object.freeze({
+    ...definition,
+    packageId: definition.packageId.slice(),
+    ...parameters === void 0 ? {} : { parameters },
+    ...sceneComponents === void 0 ? {} : { sceneComponents }
+  });
+}
+function definePack(definition) {
+  const validated = validatePackDefinition(definition);
+  if (!validated.ok) throw Object.assign(new TypeError(validated.error.hint), validated.error);
+  return cloneDefinition(
+    validated.value
+  );
+}
+function projectParameterizedPackMeta(definition, sourcePath) {
   return {
-    subject,
-    execution,
-    lifecycle,
-    operations: catalogOperationsFor({ subject, execution, lifecycle })
+    schemaVersion: "2.0.0",
+    kind: "parameterized-pack-source",
+    packageId: PackageId.format(definition.packageId),
+    source: sourcePath,
+    ..."parameters" in definition ? {
+      parameters: definition.parameters.map((parameter) => ({
+        name: parameter.name,
+        type: parameter.type,
+        default: jsonParameterValue(parameter.default),
+        ...parameter.minimum === void 0 ? {} : { minimum: parameter.minimum },
+        ...parameter.maximum === void 0 ? {} : { maximum: parameter.maximum },
+        ...parameter.values === void 0 ? {} : { values: parameter.values },
+        ...parameter.kind === void 0 ? {} : { kind: parameter.kind }
+      }))
+    } : {}
   };
 }
-function currentProjectionFor(subject, execution) {
-  return catalogRowProjectionFor(subject, execution, "current");
-}
-function catalogRowProjectionFor(subject, execution, lifecycle) {
-  const projection = catalogProjectionFor(subject, execution, lifecycle);
-  return { ...projection, projection };
+function jsonParameterValue(value) {
+  return value instanceof Uint8Array ? AssetGuid.format(value) : value;
 }
-function referenceRelations(guid, refs, provenance) {
-  if (refs === void 0 || refs.length === 0) return void 0;
-  return refs.map((ref) => ({
-    from: { type: "asset", id: guid },
-    to: { type: "asset", id: ref },
-    type: "references",
-    policy: { strength: "required" },
-    provenance
+function validatePackDefinition(value, sourcePath) {
+  if (!isRecord(value))
+    return failure(
+      parameterFailure("$", "a Pack definition object", value, "definition is not an object")
+    );
+  const unknown = Object.keys(value).find(
+    (key) => !["schemaVersion", "packageId", "name", "parameters", "sceneComponents", "build"].includes(
+      key
+    )
+  );
+  if (unknown !== void 0) {
+    return failure(
+      parameterFailure(
+        `$.${unknown}`,
+        "only schemaVersion, packageId, name, parameters, sceneComponents, and build fields",
+        value[unknown],
+        "legacy static output declarations and external asset tables are not part of v2 authoring"
+      )
+    );
+  }
+  if (value.schemaVersion !== "2.0.0") {
+    return failure(
+      parameterFailure(
+        "$.schemaVersion",
+        "the literal '2.0.0'",
+        value.schemaVersion,
+        "authoring source schema is unsupported"
+      )
+    );
+  }
+  if (!isPackageId(value.packageId)) {
+    return failure(
+      authoringError(
+        "pack-package-id-invalid",
+        "a 16-byte PackageId",
+        "use definePackageId() for the stable source identity",
+        { sourcePath, propertyPath: "$.packageId" },
+        typeof value.packageId === "string" ? value.packageId : void 0
+      )
+    );
+  }
+  if (value.name !== void 0 && typeof value.name !== "string") {
+    return failure(
+      parameterFailure("$.name", "a string when present", value.name, "display name is malformed")
+    );
+  }
+  if (typeof value.build !== "function") {
+    return failure(
+      parameterFailure("$.build", "a build function", value.build, "build is not callable")
+    );
+  }
+  const sceneComponents = validateSceneComponents(value.sceneComponents);
+  if (!sceneComponents.ok) return sceneComponents;
+  const hasParameters = Object.hasOwn(value, "parameters");
+  if (!hasParameters) {
+    return ok(
+      Object.freeze({
+        schemaVersion: "2.0.0",
+        packageId: value.packageId,
+        ...value.name === void 0 ? {} : { name: value.name },
+        ...sceneComponents.value === void 0 ? {} : { sceneComponents: sceneComponents.value },
+        build: value.build
+      })
+    );
+  }
+  const parameters = validateParameterDefinitions(value.parameters);
+  if (!parameters.ok) return parameters;
+  return ok(
+    Object.freeze({
+      schemaVersion: "2.0.0",
+      packageId: value.packageId,
+      ...value.name === void 0 ? {} : { name: value.name },
+      ...sceneComponents.value === void 0 ? {} : { sceneComponents: sceneComponents.value },
+      parameters: parameters.value,
+      build: value.build
+    })
+  );
+}
+function isParameterizedPack(value) {
+  return isRecord(value) && Array.isArray(value.parameters) && value.parameters.length > 0;
+}
+function resolvePackParameterValues(definition, overrides = {}, inheritedValues) {
+  if (!isRecord(overrides)) {
+    return failure(
+      parameterFailure(
+        "$.values",
+        "an object of sparse parameter overrides",
+        overrides,
+        "values is not an object"
+      )
+    );
+  }
+  const descriptors = new Map(
+    definition.parameters.map((parameter) => [parameter.name, parameter])
+  );
+  for (const name of Object.keys(overrides)) {
+    if (!descriptors.has(name)) {
+      return failure(
+        parameterFailure(
+          `$.values.${name}`,
+          "a declared parameter name",
+          name,
+          "instance contains an unknown parameter"
+        )
+      );
+    }
+  }
+  const values = {};
+  for (const parameter of definition.parameters) {
+    const raw = Object.hasOwn(overrides, parameter.name) ? overrides[parameter.name] : inheritedValues?.[parameter.name] ?? parameter.default;
+    const normalized = normalizeParameterValue(parameter, raw, `$.values.${parameter.name}`);
+    if (!normalized.ok) return normalized;
+    values[parameter.name] = normalized.value;
+  }
+  return ok(Object.freeze(values));
+}
+function jsonError(propertyPath, expected, actual, reason) {
+  return failure(
+    authoringError(
+      "pack-parameter-invalid",
+      expected,
+      "repair the v3 pack.json authoring data, then rerun scan or rebuild",
+      {
+        propertyPath,
+        reason,
+        actual: typeof actual === "string" ? actual : JSON.stringify(actual)
+      }
+    )
+  );
+}
+function parsePackageId(value, propertyPath) {
+  if (typeof value !== "string") {
+    return failure(
+      authoringError(
+        "pack-package-id-invalid",
+        "a UUID string",
+        "repair packageId in the authoring file",
+        { propertyPath, value }
+      )
+    );
+  }
+  const parsed = PackageId.parse(value);
+  if (!parsed.ok) {
+    return failure(
+      authoringError(
+        "pack-package-id-invalid",
+        "a 36-character RFC 4122 UUID",
+        "repair packageId or use the authoring gateway to mint one",
+        { propertyPath, value },
+        value
+      )
+    );
+  }
+  return ok(parsed.value);
+}
+function parsePackJsonAsset(value, sourceKey2) {
+  if (!isRecord(value))
+    return jsonError(
+      `$.assets.${sourceKey2}`,
+      "an asset entry object",
+      value,
+      "asset entry is not an object"
+    );
+  const allowed = /* @__PURE__ */ new Set(["kind", "payload", "refs", "name", "artifacts"]);
+  const unknown = Object.keys(value).find((key) => !allowed.has(key));
+  if (unknown !== void 0)
+    return jsonError(
+      `$.assets.${sourceKey2}.${unknown}`,
+      "no GUID or extra authoring field",
+      value[unknown],
+      "direct v3 entries derive identity from their object key"
+    );
+  if (typeof value.kind !== "string" || value.kind.length === 0)
+    return jsonError(
+      `$.assets.${sourceKey2}.kind`,
+      "a non-empty asset kind",
+      value.kind,
+      "asset kind is missing"
+    );
+  if (!isRecord(value.payload))
+    return jsonError(
+      `$.assets.${sourceKey2}.payload`,
+      "a JSON object payload",
+      value.payload,
+      "payload must be a plain object"
+    );
+  if (!Array.isArray(value.refs) || value.refs.some((ref) => typeof ref !== "string" || !isValidAssetGuidString(ref))) {
+    return jsonError(
+      `$.assets.${sourceKey2}.refs`,
+      "an array of UUID references",
+      value.refs,
+      "references must already be real AssetGuids"
+    );
+  }
+  if (value.name !== void 0 && (typeof value.name !== "string" || value.name.length === 0))
+    return jsonError(
+      `$.assets.${sourceKey2}.name`,
+      "a non-empty display name when present",
+      value.name,
+      "asset name is malformed"
+    );
+  if (value.artifacts !== void 0 && !isRecord(value.artifacts))
+    return jsonError(
+      `$.assets.${sourceKey2}.artifacts`,
+      "an artifact descriptor object when present",
+      value.artifacts,
+      "artifacts are not an object"
+    );
+  const base = {
+    kind: value.kind,
+    payload: value.payload,
+    refs: Object.freeze([...value.refs]),
+    ...value.name === void 0 ? {} : { name: value.name }
+  };
+  if (value.artifacts === void 0) return ok(base);
+  const withArtifacts = {
+    ...base,
+    artifacts: value.artifacts
+  };
+  return ok(withArtifacts);
+}
+function parseParameterizedPackJson(value) {
+  if (!isRecord(value))
+    return jsonError("$", "a v3 pack.json object", value, "document is not an object");
+  if (value.schemaVersion !== "3.0.0")
+    return jsonError(
+      "$.schemaVersion",
+      "the literal '3.0.0'",
+      value.schemaVersion,
+      "document schema is not v3"
+    );
+  const unknown = Object.keys(value).find(
+    (key) => !["schemaVersion", "packageId", "assets", "parent", "values"].includes(key)
+  );
+  if (unknown !== void 0)
+    return jsonError(
+      `$.${unknown}`,
+      "no extra top-level authoring fields",
+      value[unknown],
+      "keep the v3 document to packageId+assets or packageId+parent+values"
+    );
+  const packageResult = parsePackageId(value.packageId, "$.packageId");
+  if (!packageResult.ok) return packageResult;
+  const hasAssets = Object.hasOwn(value, "assets");
+  const hasParent = Object.hasOwn(value, "parent");
+  const hasValues = Object.hasOwn(value, "values");
+  if (hasAssets && (hasParent || hasValues))
+    return jsonError(
+      "$",
+      "assets or parent+values, never both",
+      value,
+      "direct and instance branches are mutually exclusive"
+    );
+  if (hasAssets) {
+    if (!isRecord(value.assets))
+      return jsonError(
+        "$.assets",
+        "a sourceKey to asset object",
+        value.assets,
+        "direct assets are not an object"
+      );
+    const assets = {};
+    for (const [sourceKey2, entry] of Object.entries(value.assets)) {
+      if (!isValidPackSourceKey(sourceKey2))
+        return failure(sourceKeyFailure(sourceKey2, `$.assets.${sourceKey2}`));
+      const parsed = parsePackJsonAsset(entry, sourceKey2);
+      if (!parsed.ok) return parsed;
+      assets[sourceKey2] = parsed.value;
+    }
+    return ok({
+      format: "direct",
+      schemaVersion: "3.0.0",
+      packageId: packageResult.value,
+      assets: Object.freeze(assets)
+    });
+  }
+  if (!hasParent || !hasValues || hasAssets)
+    return jsonError(
+      "$",
+      "parent and values for an instance document",
+      value,
+      "instance branch is incomplete"
+    );
+  const parentResult = parsePackageId(value.parent, "$.parent");
+  if (!parentResult.ok) return parentResult;
+  if (!isRecord(value.values))
+    return jsonError(
+      "$.values",
+      "a sparse parameter object",
+      value.values,
+      "instance values are not an object"
+    );
+  return ok({
+    format: "instance",
+    schemaVersion: "3.0.0",
+    packageId: packageResult.value,
+    parent: parentResult.value,
+    values: Object.freeze({ ...value.values })
+  });
+}
+var parsePackJson = parseParameterizedPackJson;
+var parsePackAuthoringJson = parseParameterizedPackJson;
+function projectDirectPackJson(value) {
+  const parsed = "format" in value ? ok(value) : parseParameterizedPackJson(value);
+  if (!parsed.ok) return parsed;
+  if (parsed.value.format !== "direct") {
+    return failure(
+      authoringError(
+        "pack-parameter-invalid",
+        "a direct v3 pack.json",
+        "projectDirectPackJson accepts the direct branch only",
+        { observed: parsed.value.format }
+      )
+    );
+  }
+  const assets = [];
+  for (const [sourceKey2, entry] of Object.entries(parsed.value.assets).sort(
+    ([left], [right]) => left.localeCompare(right)
+  )) {
+    assets.push({
+      ...entry,
+      guid: AssetGuid.format(AssetGuid.derive(parsed.value.packageId, sourceKey2)),
+      sourceKey: sourceKey2
+    });
+  }
+  return ok({ packageId: PackageId.format(parsed.value.packageId), assets: Object.freeze(assets) });
+}
+function subjectId(subject) {
+  return PackageId.format(subject.packageId).toLowerCase();
+}
+async function resolvePackParameterInheritance(subject, readParent) {
+  const visited = /* @__PURE__ */ new Set();
+  async function visit(current, path) {
+    const currentId = subjectId(current);
+    if (visited.has(currentId) || path.includes(currentId)) {
+      return failure(
+        authoringError(
+          "pack-parent-cycle",
+          "a finite acyclic Pack parent chain",
+          "inspect parentChain and repair the first repeated packageId",
+          { packageId: currentId, parentChain: [...path, currentId] }
+        )
+      );
+    }
+    visited.add(currentId);
+    const nextPath = [...path, currentId];
+    if (current.format === "direct") {
+      return failure(
+        authoringError(
+          "pack-parent-not-parameterized",
+          "a parameterized Pack source as the parent",
+          "direct packs cannot be instance parents; point the instance at a parameterized source",
+          { packageId: currentId }
+        )
+      );
+    }
+    if (current.format === "source") {
+      const descriptors2 = validateParameterDefinitions(current.parameters, "$.parameters");
+      if (!descriptors2.ok) return descriptors2;
+      if (descriptors2.value.length === 0) {
+        return failure(
+          authoringError(
+            "pack-parent-not-parameterized",
+            "the parent source to declare a non-empty parameter list",
+            "use clone for an independent zero-parameter Pack instead of creating an empty instance",
+            { packageId: currentId }
+          )
+        );
+      }
+      const definition2 = {
+        packageId: current.packageId,
+        parameters: descriptors2.value};
+      const values2 = resolvePackParameterValues(definition2);
+      if (!values2.ok) return values2;
+      return ok({
+        packageId: current.packageId,
+        rootPackageId: current.packageId,
+        values: values2.value,
+        parentChain: [],
+        parameters: descriptors2.value
+      });
+    }
+    const parent = await readParent(current.parent);
+    if (parent === void 0) {
+      return failure(
+        authoringError(
+          "pack-parent-not-found",
+          "the parent packageId to resolve in the source index",
+          "inspect the parent locator or recreate the instance from a live parameterized Pack",
+          { packageId: currentId, parent: PackageId.format(current.parent) }
+        )
+      );
+    }
+    if (PackageId.format(parent.packageId).toLowerCase() !== PackageId.format(current.parent).toLowerCase()) {
+      return failure(
+        authoringError(
+          "pack-parent-not-found",
+          "the parent reader to return the requested packageId",
+          "repair the Source Index locator and retry inheritance resolution",
+          {
+            packageId: currentId,
+            requestedParent: PackageId.format(current.parent),
+            observedParent: PackageId.format(parent.packageId)
+          }
+        )
+      );
+    }
+    const resolvedParent = await visit(parent, nextPath);
+    if (!resolvedParent.ok) return resolvedParent;
+    const descriptors = resolvedParent.value.parameters;
+    const definition = {
+      packageId: resolvedParent.value.rootPackageId,
+      parameters: descriptors};
+    const values = resolvePackParameterValues(
+      definition,
+      current.values,
+      resolvedParent.value.values
+    );
+    if (!values.ok) return values;
+    return ok({
+      packageId: current.packageId,
+      rootPackageId: resolvedParent.value.rootPackageId,
+      values: values.value,
+      parentChain: [PackageId.format(current.parent), ...resolvedParent.value.parentChain],
+      parameters: descriptors
+    });
+  }
+  return visit(subject, []);
+}
+var resolvePackInheritance = resolvePackParameterInheritance;
+var PARAMETERIZED_PACK_OPERATION_IDS = [
+  "asset.list",
+  "asset.inspect",
+  "asset.resolve",
+  "asset.verify",
+  "asset-source.create",
+  "asset-source.clone",
+  "asset-source.create-instance",
+  "asset-source.apply-values",
+  "asset-source.rebuild",
+  "asset-source.cold-cook"
+];
+function createParameterizedPackAuthoringGateway(port) {
+  const requests = /* @__PURE__ */ new Map();
+  return {
+    execute(operation) {
+      if (typeof operation.requestId !== "string" || operation.requestId.trim().length === 0) {
+        return Promise.resolve(
+          failure(
+            authoringError(
+              "pack-source-revision-conflict",
+              "a non-empty caller-minted requestId",
+              "mint a new requestId and retry",
+              { requestId: operation.requestId }
+            )
+          )
+        );
+      }
+      let fingerprint;
+      try {
+        fingerprint = JSON.stringify(operation);
+      } catch (cause) {
+        return Promise.resolve(
+          failure(
+            authoringError(
+              "pack-parameter-invalid",
+              "a JSON-serialisable authoring operation",
+              "remove non-serialisable operation fields and retry with a new requestId",
+              {
+                requestId: operation.requestId,
+                cause: cause instanceof Error ? cause.message : String(cause)
+              }
+            )
+          )
+        );
+      }
+      const previous = requests.get(operation.requestId);
+      if (previous !== void 0) {
+        if (previous.fingerprint === fingerprint) return previous.result;
+        return Promise.resolve(
+          failure(
+            authoringError(
+              "pack-source-revision-conflict",
+              "one immutable operation per requestId",
+              "read the original result or mint a new requestId",
+              { requestId: operation.requestId }
+            )
+          )
+        );
+      }
+      const result = Promise.resolve().then(() => port.execute(operation)).catch(
+        (cause) => failure(
+          authoringError(
+            "pack-parameter-invalid",
+            "the Pack authoring port to return a structured Result",
+            "repair the gateway port failure, then retry with a new requestId",
+            {
+              requestId: operation.requestId,
+              cause: cause instanceof Error ? cause.message : String(cause)
+            }
+          )
+        )
+      );
+      requests.set(operation.requestId, { fingerprint, result });
+      return result;
+    }
+  };
+}
+var PARAMETERIZED_PACK_OPERATION_DESCRIPTORS = PARAMETERIZED_PACK_OPERATION_IDS.map(
+  (id) => ({
+    id,
+    domain: id.startsWith("asset-source.") ? "session" : "asset",
+    readOnly: id.startsWith("asset."),
+    requiresRevision: !id.startsWith("asset.") && id !== "asset-source.create"
+  })
+);
+
+// src/scriptable-pack.ts
+var SCRIPTABLE_PACK_ASSET_KINDS = [
+  "mesh",
+  "material",
+  "scene",
+  "texture",
+  "equirect",
+  "sampler",
+  "font",
+  "render-pipeline",
+  "tileset",
+  "video",
+  "skeleton",
+  "skin",
+  "animation-clip",
+  "animation-graph",
+  "audio",
+  "particle-effect",
+  "ies-profile"
+];
+function isScriptablePackAssetKind(value) {
+  return SCRIPTABLE_PACK_ASSET_KINDS.includes(value);
+}
+function sceneComponentFieldType(value) {
+  if (typeof value === "string") return value;
+  if (value === null || typeof value !== "object" || Array.isArray(value)) return void 0;
+  const type = value.type;
+  return typeof type === "string" ? type : void 0;
+}
+function projectScriptablePackSceneComponents(components) {
+  return (components ?? []).map((component) => ({
+    name: component.name,
+    fields: Object.fromEntries(
+      Object.entries(component.fields).map(([fieldName, field]) => [
+        fieldName,
+        sceneComponentFieldType(field)
+      ])
+    )
+  }));
+}
+
+// src/catalog-projection.ts
+function catalogProjectionFor(subject, execution, lifecycle) {
+  return {
+    subject,
+    execution,
+    lifecycle,
+    operations: catalogOperationsFor({ subject, execution, lifecycle })
+  };
+}
+function currentProjectionFor(subject, execution) {
+  return catalogRowProjectionFor(subject, execution, "current");
+}
+function catalogRowProjectionFor(subject, execution, lifecycle) {
+  const projection = catalogProjectionFor(subject, execution, lifecycle);
+  return { ...projection, projection };
+}
+function referenceRelations(guid, refs, provenance) {
+  if (refs === void 0 || refs.length === 0) return void 0;
+  return refs.map((ref) => ({
+    from: { type: "asset", id: guid },
+    to: { type: "asset", id: ref },
+    type: "references",
+    policy: { strength: "required" },
+    provenance
   }));
 }
 function producerFields(producer, output) {
@@ -7531,10 +8146,10 @@ function projectCookedPackageEntry(entry, projection) {
     refs: projection.refs
   };
 }
-function runtimeCatalogRowError(subjectId, expected) {
+function runtimeCatalogRowError(subjectId2, expected) {
   const diagnostic = {
     code: "invalid-producer-fact",
-    subject: { type: "asset", id: subjectId },
+    subject: { type: "asset", id: subjectId2 },
     expected,
     hint: "recook the source and publish one current runtime Catalog row",
     authority: "producer"
@@ -7585,27 +8200,6 @@ function projectRuntimeCatalogRow(input) {
   }
   return projectRuntimeCatalogRowValue(input);
 }
-function loadAssetConfig(cwd) {
-  let pkg;
-  try {
-    pkg = JSON.parse(readFileSync(join(cwd, "package.json"), "utf-8"));
-  } catch {
-    return { roots: [join(cwd, "assets")], paths: {} };
-  }
-  const assets = pkg.forgeax?.assets;
-  const rawRoots = assets?.roots;
-  const roots = Array.isArray(rawRoots) && rawRoots.length > 0 ? rawRoots.map((r) => join(cwd, r)) : [join(cwd, "assets")];
-  const rawPaths = assets?.paths;
-  const paths = {};
-  if (rawPaths !== void 0 && rawPaths !== null && typeof rawPaths === "object") {
-    for (const [name, dir] of Object.entries(rawPaths)) {
-      if (typeof dir === "string") {
-        paths[name] = join(cwd, dir);
-      }
-    }
-  }
-  return { roots, paths };
-}
 
 // src/deriveAssetName.ts
 function baseName(p) {
@@ -7613,85 +8207,26 @@ function baseName(p) {
   const idx = Math.max(trimmed.lastIndexOf("/"), trimmed.lastIndexOf("\\"));
   return idx === -1 ? trimmed : trimmed.slice(idx + 1);
 }
-function deriveAssetName(packagePath, assetCount, storedName) {
-  if (packagePath === null) {
-    return storedName ?? "";
-  }
-  if (assetCount === 1) {
-    return baseName(packagePath);
-  }
+function deriveAssetName(packagePath, _assetCount, storedName) {
   if (storedName !== void 0) {
     return storedName;
   }
+  if (packagePath === null) {
+    return "";
+  }
   return baseName(packagePath);
 }
 function deriveSourceName(metaFileName) {
   return metaFileName.replace(/\.meta\.json$/, "");
 }
-var PATH_REF_RE = /^@([^/]+)\/(.+)$/;
-function isPathEscape(pathDir, resolved) {
-  const rel = posix.relative(pathDir, resolved);
-  return rel.startsWith("..") || posix.isAbsolute(rel);
-}
-function resolveAssetSource(metaPath, source, paths) {
+function resolveAssetSource(metaPath, source) {
   if (source === void 0) {
     const metaDir = dirname(metaPath);
-    const metaName = deriveAssetName(metaPath, 1);
+    const metaName = deriveAssetName(metaPath);
     const derived = deriveSourceName(metaName);
-    return ok(resolve(metaDir, derived));
-  }
-  if (source.startsWith("@")) {
-    const match = source.match(PATH_REF_RE);
-    if (!match) {
-      return err(
-        new PackError({
-          code: "pack-malformed-path-ref",
-          expected: "source in format @<name>/<rest>",
-          hint: PACK_ERROR_HINTS["pack-malformed-path-ref"],
-          detail: {
-            code: "pack-malformed-path-ref",
-            reason: "format",
-            rawSource: source,
-            expectedFormat: "@<name>/<rest>"
-          }
-        })
-      );
-    }
-    const [, name, rest] = match;
-    const pathDir = paths[name];
-    if (pathDir === void 0) {
-      return err(
-        new PackError({
-          code: "pack-unknown-path",
-          expected: "path name found in package.json#forgeax.assets.paths",
-          hint: PACK_ERROR_HINTS["pack-unknown-path"],
-          detail: {
-            code: "pack-unknown-path",
-            pathName: name,
-            knownNames: Object.keys(paths)
-          }
-        })
-      );
-    }
-    const resolved = resolve(pathDir, rest);
-    if (isPathEscape(pathDir, resolved)) {
-      return err(
-        new PackError({
-          code: "pack-malformed-path-ref",
-          expected: "rest path must not escape the declared path directory",
-          hint: PACK_ERROR_HINTS["pack-malformed-path-ref"],
-          detail: {
-            code: "pack-malformed-path-ref",
-            reason: "escape",
-            rawSource: source,
-            expectedFormat: "@<name>/<rest>"
-          }
-        })
-      );
-    }
-    return ok(resolved);
+    return resolve(metaDir, derived);
   }
-  return ok(resolve(dirname(metaPath), source));
+  return resolve(dirname(metaPath), source);
 }
 function isRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -7699,25 +8234,25 @@ function isRecord2(value) {
 function hasText(value) {
   return typeof value === "string" && value.length > 0;
 }
-function issue(code, subjectId, expected, hint, actual2, authority = "producer") {
-  const subject = { type: "asset", id: subjectId };
+function issue(code, subjectId2, expected, hint, actual, authority = "producer") {
+  const subject = { type: "asset", id: subjectId2 };
   return {
     ok: false,
     error: {
       code,
       subject,
       expected,
-      ...actual2 === void 0 ? {} : { actual: actual2 },
+      ...actual === void 0 ? {} : { actual },
       hint,
       authority
     }
   };
 }
-function validateFacts(value, subjectId) {
+function validateFacts(value, subjectId2) {
   if ("packageId" in value && !hasText(value.packageId)) {
     return issue(
       "invalid-producer-fact",
-      subjectId,
+      subjectId2,
       "packageId must be a non-empty string",
       "publish a stable package identity"
     );
@@ -7727,7 +8262,7 @@ function validateFacts(value, subjectId) {
     if (!isRecord2(provenance) || !hasText(provenance.provider) || !hasText(provenance.version)) {
       return issue(
         "invalid-producer-fact",
-        subjectId,
+        subjectId2,
         "provenance.provider and provenance.version must be non-empty",
         "publish provider identity and version"
       );
@@ -7738,7 +8273,7 @@ function validateFacts(value, subjectId) {
     if (!isRecord2(revision) || !hasText(revision.digest) || !hasText(revision.rootId) || typeof revision.observedAt !== "number" || !Number.isFinite(revision.observedAt)) {
       return issue(
         "invalid-producer-fact",
-        subjectId,
+        subjectId2,
         "revision.digest, revision.rootId and finite revision.observedAt",
         "publish a complete resource revision"
       );
@@ -7748,7 +8283,7 @@ function validateFacts(value, subjectId) {
     if (!Array.isArray(value.diagnostics)) {
       return issue(
         "invalid-producer-fact",
-        subjectId,
+        subjectId2,
         "diagnostics must be an array",
         "publish structured diagnostics as an array"
       );
@@ -7757,7 +8292,7 @@ function validateFacts(value, subjectId) {
       if (!isRecord2(diagnostic) || !hasText(diagnostic.code)) {
         return issue(
           "invalid-producer-fact",
-          subjectId,
+          subjectId2,
           "each diagnostic needs a stable code",
           "publish a machine-readable diagnostic code"
         );
@@ -7766,7 +8301,7 @@ function validateFacts(value, subjectId) {
         if (!isRecord2(diagnostic.subject) || !hasText(diagnostic.subject.id)) {
           return issue(
             "invalid-producer-fact",
-            subjectId,
+            subjectId2,
             "blocking diagnostic.subject must identify an object",
             "set subject.type and subject.id"
           );
@@ -7774,7 +8309,7 @@ function validateFacts(value, subjectId) {
         if (!hasText(diagnostic.expected) || !hasText(diagnostic.hint)) {
           return issue(
             "invalid-producer-fact",
-            subjectId,
+            subjectId2,
             "blocking diagnostics need expected and hint",
             "provide an executable recovery hint"
           );
@@ -7784,7 +8319,7 @@ function validateFacts(value, subjectId) {
   }
   return { ok: true, value };
 }
-function validateMetaSourceOverrides(value, subjectId) {
+function validateMetaSourceOverrides(value, subjectId2) {
   if (!("sourceOverrides" in value)) return { ok: true, value };
   const declaredSourceKeys = Array.isArray(value.subAssets) ? value.subAssets.flatMap(
     (subAsset) => isRecord2(subAsset) && hasText(subAsset.sourceKey) ? [subAsset.sourceKey] : []
@@ -7793,7 +8328,7 @@ function validateMetaSourceOverrides(value, subjectId) {
   if (!result.ok) {
     return issue(
       result.error.code,
-      subjectId,
+      subjectId2,
       result.error.expected,
       result.error.hint,
       result.error.actual,
@@ -7814,15 +8349,15 @@ function validateProducerContract(value) {
       "publish a JSON object"
     );
   }
-  const subjectId = hasText(value.guid) ? value.guid : hasText(value.packageId) ? value.packageId : "unknown";
-  const facts = validateFacts(value, subjectId);
+  const subjectId2 = hasText(value.guid) ? value.guid : hasText(value.packageId) ? value.packageId : "unknown";
+  const facts = validateFacts(value, subjectId2);
   if (!facts.ok) return facts;
-  const metaOverrides = validateMetaSourceOverrides(value, subjectId);
+  const metaOverrides = validateMetaSourceOverrides(value, subjectId2);
   if (!metaOverrides.ok) return metaOverrides;
   if ("kind" in value && !hasText(value.kind)) {
     return issue(
       "invalid-producer-fact",
-      subjectId,
+      subjectId2,
       "kind must be a non-empty open string",
       "publish the provider-owned asset kind"
     );
@@ -7830,7 +8365,7 @@ function validateProducerContract(value) {
   if ("execution" in value && value.execution !== "direct" && value.execution !== "cooked") {
     return issue(
       "invalid-producer-fact",
-      subjectId,
+      subjectId2,
       "execution must be either direct or cooked",
       "publish the explicit authoring execution mode"
     );
@@ -7840,7 +8375,7 @@ function validateProducerContract(value) {
   if (value.sourceKey !== void 0 && !hasText(value.sourceKey)) {
     return issue(
       "invalid-source-key",
-      subjectId,
+      subjectId2,
       "sourceKey must be a non-empty producer-owned string",
       "publish a stable semantic sourceKey"
     );
@@ -7848,7 +8383,7 @@ function validateProducerContract(value) {
   if (value.sourceIndex !== void 0 && (typeof value.sourceIndex !== "number" || !Number.isInteger(value.sourceIndex) || value.sourceIndex < 0)) {
     return issue(
       "invalid-source-index",
-      subjectId,
+      subjectId2,
       "sourceIndex must be a non-negative integer locator",
       "publish a non-negative sourceIndex without using it as identity"
     );
@@ -7856,7 +8391,7 @@ function validateProducerContract(value) {
   if (value.sourceKey === void 0 && value.sourceIndex !== void 0) {
     return issue(
       "missing-source-key",
-      subjectId,
+      subjectId2,
       "sourceKey is required when an output declares sourceIndex",
       "publish a stable semantic key; do not derive identity from sourceIndex"
     );
@@ -7864,7 +8399,7 @@ function validateProducerContract(value) {
   if ("compatiblePreviousKinds" in value && (!Array.isArray(value.compatiblePreviousKinds) || value.compatiblePreviousKinds.some((kind) => !hasText(kind)))) {
     return issue(
       "invalid-producer-fact",
-      subjectId,
+      subjectId2,
       "compatiblePreviousKinds must be an array of non-empty kind strings",
       "declare only producer-verified prior kinds that may preserve the GUID"
     );
@@ -7949,7 +8484,7 @@ var meta_schema_default = {
     source: {
       type: "string",
       minLength: 1,
-      description: "Optional. Omit to derive the companion file in the same directory (strip .meta.json suffix from the meta filename). Or write @<name>/<rest> to reference a declared path table entry (see package.json#forgeax.assets.paths). Existing relative paths remain unchanged."
+      description: "Optional. Omit to derive the companion file in the same directory (strip .meta.json suffix from the meta filename). An explicit source is resolved relative to this sidecar."
     },
     importSettings: {
       type: "object",
@@ -8090,11 +8625,11 @@ var pack_schema_default = {
   $comment: "The ordinary durable consumer matrix is SCRIPTABLE_PACK_ASSET_KINDS in @forgeax/engine-pack/source. Pack kind fields remain open for registered producer extensions.",
   type: "object",
   additionalProperties: false,
-  required: ["schemaVersion", "kind", "assets"],
+  required: ["schemaVersion"],
   properties: {
     schemaVersion: {
       type: "string",
-      enum: ["1.0.0", "2.0.0"]
+      enum: ["1.0.0", "2.0.0", "3.0.0"]
     },
     kind: {
       type: "string",
@@ -8116,12 +8651,58 @@ var pack_schema_default = {
       items: { $ref: "#/$defs/diagnostic" }
     },
     assets: {
-      type: "array",
-      items: {
-        $ref: "#/$defs/asset"
-      }
+      oneOf: [
+        {
+          type: "array",
+          items: { $ref: "#/$defs/asset" }
+        },
+        { $ref: "#/$defs/authoringAssets" }
+      ]
+    },
+    parent: {
+      $ref: "#/$defs/guid36",
+      description: "Parent parameterized Pack packageId for one v3 instance."
+    },
+    values: {
+      type: "object",
+      additionalProperties: true,
+      description: "Sparse shallow parameter overrides for one v3 instance."
     }
   },
+  oneOf: [
+    {
+      required: ["kind", "assets"],
+      properties: {
+        schemaVersion: { enum: ["1.0.0", "2.0.0"] },
+        kind: { const: "internal-text-package" },
+        assets: { type: "array" },
+        parent: false,
+        values: false
+      }
+    },
+    {
+      required: ["packageId", "assets"],
+      properties: {
+        schemaVersion: { const: "3.0.0" },
+        kind: false,
+        packageId: { $ref: "#/$defs/guid36" },
+        assets: { $ref: "#/$defs/authoringAssets" },
+        parent: false,
+        values: false
+      }
+    },
+    {
+      required: ["packageId", "parent", "values"],
+      properties: {
+        schemaVersion: { const: "3.0.0" },
+        kind: false,
+        packageId: { $ref: "#/$defs/guid36" },
+        parent: { $ref: "#/$defs/guid36" },
+        values: { type: "object" },
+        assets: false
+      }
+    }
+  ],
   allOf: [
     {
       if: {
@@ -8213,16 +8794,40 @@ var pack_schema_default = {
         }
       ]
     },
-    artifacts: {
+    authoringAssets: {
       type: "object",
       additionalProperties: false,
       patternProperties: {
-        "^[A-Za-z0-9][A-Za-z0-9._/-]*$": {
-          $ref: "#/$defs/artifactDescriptor"
+        "^[a-z0-9][a-z0-9._-]*(/[a-z0-9][a-z0-9._-]*)*$": {
+          $ref: "#/$defs/authoringAsset"
         }
       }
     },
-    artifactDescriptor: {
+    authoringAsset: {
+      type: "object",
+      additionalProperties: false,
+      required: ["kind", "payload", "refs"],
+      properties: {
+        kind: { type: "string", minLength: 1 },
+        name: { type: "string", minLength: 1 },
+        payload: { type: "object" },
+        refs: {
+          type: "array",
+          items: { $ref: "#/$defs/guid36" }
+        },
+        artifacts: { $ref: "#/$defs/artifacts" }
+      }
+    },
+    artifacts: {
+      type: "object",
+      additionalProperties: false,
+      patternProperties: {
+        "^[A-Za-z0-9][A-Za-z0-9._/-]*$": {
+          $ref: "#/$defs/artifactDescriptor"
+        }
+      }
+    },
+    artifactDescriptor: {
       type: "object",
       additionalProperties: false,
       required: ["path", "mediaType"],
@@ -8379,50 +8984,51 @@ async function inventoryScriptablePackSource(sourcePath, initialSourceText) {
 }
 function serializeFailure(value) {
   if (value !== null && typeof value === "object") {
-    const failure3 = value;
+    const failure5 = value;
     return {
-      name: failure3.name,
-      code: failure3.code,
-      expected: failure3.expected,
-      actual: failure3.actual,
-      hint: failure3.hint,
-      detail: failure3.detail,
-      message: failure3.message
+      name: failure5.name,
+      code: failure5.code,
+      expected: failure5.expected,
+      actual: failure5.actual,
+      hint: failure5.hint,
+      detail: failure5.detail,
+      message: failure5.message
     };
   }
   return { message: String(value) };
 }
 function hydrateFailure(value) {
   if (value === null || typeof value !== "object") return value;
-  const failure3 = value;
-  if (failure3.name === "AssetError" && typeof failure3.code === "string" && typeof failure3.expected === "string" && typeof failure3.hint === "string") {
+  const failure5 = value;
+  if (failure5.name === "AssetError" && typeof failure5.code === "string" && typeof failure5.expected === "string" && typeof failure5.hint === "string") {
     const args = {
-      code: failure3.code,
-      expected: failure3.expected,
-      hint: failure3.hint
+      code: failure5.code,
+      expected: failure5.expected,
+      hint: failure5.hint
     };
-    return failure3.detail === void 0 ? new AssetError(args) : new AssetError({
+    return failure5.detail === void 0 ? new AssetError(args) : new AssetError({
       ...args,
-      detail: failure3.detail
+      detail: failure5.detail
     });
   }
-  if (failure3.name === "ImportError" && typeof failure3.code === "string" && typeof failure3.expected === "string" && typeof failure3.hint === "string" && failure3.detail !== void 0) {
+  if (failure5.name === "ImportError" && typeof failure5.code === "string" && typeof failure5.expected === "string" && typeof failure5.hint === "string" && failure5.detail !== void 0) {
     return new ImportError({
-      code: failure3.code,
-      expected: failure3.expected,
-      hint: failure3.hint,
-      detail: failure3.detail,
-      ...typeof failure3.actual === "string" ? { actual: failure3.actual } : {}
+      code: failure5.code,
+      expected: failure5.expected,
+      hint: failure5.hint,
+      detail: failure5.detail,
+      ...typeof failure5.actual === "string" ? { actual: failure5.actual } : {}
     });
   }
-  if (typeof failure3.message === "string") {
-    const error = new Error(failure3.message);
-    if (typeof failure3.name === "string") error.name = failure3.name;
+  if (typeof failure5.message === "string") {
+    const error = new Error(failure5.message);
+    if (typeof failure5.name === "string") error.name = failure5.name;
     return error;
   }
   return value;
 }
 var WorkerScriptablePackExecutor = class {
+  supportsParameterizedContext = true;
   worker;
   compileRoot;
   nextBuildId = 0;
@@ -8450,7 +9056,7 @@ var WorkerScriptablePackExecutor = class {
           resolveLoad({
             default: value.definition === void 0 ? void 0 : {
               ...value.definition,
-              build: (reader) => this.runBuild(reader)
+              build: (readByGuid, context) => this.runBuild({ readByGuid }, context)
             }
           });
         } else if (value.kind === "load-threw") {
@@ -8482,7 +9088,7 @@ var WorkerScriptablePackExecutor = class {
     })();
     return this.disposal;
   }
-  runBuild(reader) {
+  runBuild(reader, context) {
     const worker = this.worker;
     if (worker === void 0) return Promise.reject(new Error("ScriptablePack worker is closed"));
     if (this.build !== void 0)
@@ -8490,7 +9096,7 @@ var WorkerScriptablePackExecutor = class {
     const id = this.nextBuildId++;
     return new Promise((resolveBuild, rejectBuild) => {
       this.build = { id, reader, resolve: resolveBuild, reject: rejectBuild };
-      worker.postMessage({ kind: "build", buildId: id });
+      worker.postMessage({ kind: "build", buildId: id, context });
     });
   }
   onMessage(message) {
@@ -8523,11 +9129,11 @@ function scriptablePackWorkerUrl() {
   const bundledWorker = new URL("./scriptable-pack-worker.mjs", import.meta.url);
   return existsSync(fileURLToPath(bundledWorker)) ? bundledWorker : new URL("../dist/scriptable-pack-worker.mjs", import.meta.url);
 }
-function loadFailure(sourcePath, reason, phase, diagnostic, timeoutMs) {
-  return err({
-    code: "pack-source-load-failed",
-    expected: "a trusted synchronous module with a valid default ScriptablePack export",
-    hint: "repair the module load or initialization failure, then inspect Meta again",
+function parameterizedLoadFailure(sourcePath, reason, phase, diagnostic, timeoutMs) {
+  return {
+    code: "pack-parameter-invalid",
+    expected: "a trusted Pack v2 authoring module with a valid default export",
+    hint: "repair the source module or its build timeout, then inspect the Pack again",
     detail: {
       sourcePath,
       reason,
@@ -8535,70 +9141,71 @@ function loadFailure(sourcePath, reason, phase, diagnostic, timeoutMs) {
       diagnostic,
       ...timeoutMs === void 0 ? {} : { timeoutMs }
     }
-  });
-}
-function buildTimeoutFailure(sourcePath, timeoutMs) {
-  return {
-    code: "pack-source-load-failed",
-    expected: "a ScriptablePack build to settle within the configured build timeout",
-    hint: "repair the authored build, then retry through a fresh ScriptablePack generation",
-    detail: {
-      sourcePath,
-      reason: "timeout",
-      phase: "build",
-      timeoutMs,
-      diagnostic: `ScriptablePack build exceeded ${timeoutMs}ms`
-    }
   };
 }
-async function loadScriptablePack(sourcePath, options = {}) {
+async function loadParameterizedScriptablePack(sourcePath, options = {}) {
   const timeoutMs = options.timeoutMs ?? 15e3;
   const buildTimeoutMs = options.buildTimeoutMs ?? 5e3;
   const executor = options.executor ?? new WorkerScriptablePackExecutor();
   let disposeReason;
   let timeout;
   try {
-    const timeoutSignal = /* @__PURE__ */ Symbol("scriptable-pack-module-timeout");
+    const timeoutSignal = /* @__PURE__ */ Symbol("parameterized-pack-module-timeout");
     const loaded = await Promise.race([
       executor.load(sourcePath),
-      new Promise((resolve3) => {
-        timeout = setTimeout(() => resolve3(timeoutSignal), timeoutMs);
+      new Promise((resolve4) => {
+        timeout = setTimeout(() => resolve4(timeoutSignal), timeoutMs);
       })
     ]);
     if (loaded === timeoutSignal) {
       disposeReason = "timeout";
-      return loadFailure(
-        sourcePath,
-        "timeout",
-        "module-load",
-        `ScriptablePack module initialization exceeded ${timeoutMs}ms`,
-        timeoutMs
+      return err(
+        parameterizedLoadFailure(
+          sourcePath,
+          "timeout",
+          "module-load",
+          `Pack module initialization exceeded ${timeoutMs}ms`,
+          timeoutMs
+        )
       );
     }
     const moduleValue = loaded !== null && typeof loaded === "object" && "default" in loaded ? loaded.default : void 0;
-    const validated = validateScriptablePackDefinition(moduleValue, sourcePath);
+    const validated = validatePackDefinition(moduleValue, sourcePath);
     if (!validated.ok) {
       disposeReason = "failure";
       return validated;
     }
     if (options.metadataOnly === true) {
       disposeReason = "complete";
-      return validated;
+      return ok(validated.value);
     }
     const definition = validated.value;
+    const build = definition.build;
     return ok({
       ...definition,
-      build: async (reader) => {
+      build: async (context) => {
         let buildTimedOut = false;
         let buildTimeout;
-        const timeoutResult = err(buildTimeoutFailure(sourcePath, buildTimeoutMs));
+        const timeoutResult = err(
+          parameterizedLoadFailure(
+            sourcePath,
+            "timeout",
+            "build",
+            `ScriptablePack build exceeded ${buildTimeoutMs}ms`,
+            buildTimeoutMs
+          )
+        );
         try {
+          const invocation = "supportsParameterizedContext" in executor && executor.supportsParameterizedContext === true ? build(context.readByGuid, {
+            packageId: [...context.packageId],
+            ..."values" in context && context.values !== void 0 ? { values: context.values } : {}
+          }) : definition.build(context);
           const built = await Promise.race([
-            Promise.resolve(definition.build(reader)),
-            new Promise((resolve3) => {
+            Promise.resolve(invocation),
+            new Promise((resolve4) => {
               buildTimeout = setTimeout(() => {
                 buildTimedOut = true;
-                resolve3(timeoutResult);
+                resolve4(timeoutResult);
               }, buildTimeoutMs);
             })
           ]);
@@ -8617,9 +9224,15 @@ async function loadScriptablePack(sourcePath, options = {}) {
       }
     });
   } catch (error) {
-    const diagnostic = error instanceof Error ? error.message : String(error);
     disposeReason = "failure";
-    return loadFailure(sourcePath, "module-load", "module-load", diagnostic);
+    return err(
+      parameterizedLoadFailure(
+        sourcePath,
+        "module-load",
+        "module-load",
+        error instanceof Error ? error.message : String(error)
+      )
+    );
   } finally {
     if (timeout !== void 0) clearTimeout(timeout);
     if (disposeReason !== void 0) await executor.dispose?.(disposeReason);
@@ -8633,11 +9246,15 @@ function ok4(value) {
 function packErr(error) {
   return { ok: false, error };
 }
+function record(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
 var STANDARD_SCRIPTABLE_PACK_SCAN_OPTIONS = Object.freeze(
   {}
 );
 var BLACKLIST = /* @__PURE__ */ new Set([
   "node_modules",
+  "__tests__",
   ".forgeax-harness",
   ".forgeax",
   ".git",
@@ -8740,10 +9357,87 @@ async function scanValidated(roots, opts = {}, capture) {
   const scriptablePaths = rawPaths.filter((p) => p.endsWith(".pack.ts"));
   const guidToPath = /* @__PURE__ */ new Map();
   const packRefs = /* @__PURE__ */ new Map();
+  const packageIdToPath = /* @__PURE__ */ new Map();
+  const packageKind = /* @__PURE__ */ new Map();
+  const instanceParents = [];
+  function registerPackage(packageId2, path, kind) {
+    if (packageId2 === void 0) return void 0;
+    const normalized = packageId2.toLowerCase();
+    const existing = packageIdToPath.get(normalized);
+    if (existing !== void 0) {
+      return makePackError("pack-guid-collision", {
+        paths: [existing, path],
+        guid: normalized
+      });
+    }
+    packageIdToPath.set(normalized, path);
+    packageKind.set(normalized, kind);
+    return void 0;
+  }
   for (const packPath of packPaths) {
     const loaded = await readValidatedJson(packPath, "pack-malformed-pack", validatePack);
     if (!loaded.ok) return loaded;
     const { raw, parsed } = loaded.value;
+    if (record(parsed) && parsed.schemaVersion === "3.0.0") {
+      const authoring = parseParameterizedPackJson(parsed);
+      if (!authoring.ok) {
+        return packErr(
+          makePackError("pack-malformed-pack", {
+            path: packPath,
+            ajvErrors: [{ instancePath: "", message: authoring.error.code }]
+          })
+        );
+      }
+      const packageId2 = authoring.value.packageId;
+      const packageCollision2 = registerPackage(
+        PackageId.format(packageId2),
+        packPath,
+        authoring.value.format
+      );
+      if (packageCollision2 !== void 0) return packErr(packageCollision2);
+      if (authoring.value.format === "instance") {
+        instanceParents.push({
+          path: packPath,
+          packageId: PackageId.format(authoring.value.packageId),
+          parent: PackageId.format(authoring.value.parent)
+        });
+      } else {
+        const projected = projectDirectPackJson(authoring.value);
+        if (!projected.ok) {
+          return packErr(
+            makePackError("pack-malformed-pack", {
+              path: packPath,
+              ajvErrors: [{ instancePath: "/assets", message: projected.error.code }]
+            })
+          );
+        }
+        for (const asset of projected.value.assets) {
+          const normalizedGuid = asset.guid.toLowerCase();
+          const existing = guidToPath.get(normalizedGuid);
+          if (existing !== void 0) {
+            return packErr(
+              makePackError("pack-guid-collision", {
+                paths: [existing, packPath],
+                guid: normalizedGuid
+              })
+            );
+          }
+          guidToPath.set(normalizedGuid, packPath);
+          packRefs.set(normalizedGuid, [
+            ...asset.refs.map((ref) => ref.toLowerCase()),
+            ...extractMountSourceGuids(asset)
+          ]);
+        }
+      }
+      capture?.declarations.set(packPath, {
+        format: "pack.json",
+        sourcePath: packPath,
+        sourceRevision: `sha256:${createHash("sha256").update(raw).digest("hex")}`,
+        sourceText: raw,
+        value: parsed
+      });
+      continue;
+    }
     const packageContract = validateProducerContract(parsed);
     if (!packageContract.ok) {
       return packErr(
@@ -8754,6 +9448,8 @@ async function scanValidated(roots, opts = {}, capture) {
       );
     }
     const packObj = parsed;
+    const packageCollision = registerPackage(packObj.packageId, packPath, "legacy");
+    if (packageCollision !== void 0) return packErr(packageCollision);
     for (const asset of packObj.assets) {
       if (asset.kind === "particle-effect" && asset.execution === "direct" && (asset.refs.length > 0 || Object.keys(asset.artifacts ?? {}).length > 0)) {
         return packErr(
@@ -8844,7 +9540,6 @@ async function scanValidated(roots, opts = {}, capture) {
       value: packObj
     });
   }
-  const { paths: assetPaths } = loadAssetConfig(process.cwd());
   for (const metaPath of metaPaths) {
     const loaded = await readValidatedJson(metaPath, "pack-malformed-meta", validateMeta);
     if (!loaded.ok) return loaded;
@@ -8859,6 +9554,8 @@ async function scanValidated(roots, opts = {}, capture) {
       );
     }
     const metaObj = parsed;
+    const packageCollision = registerPackage(metaObj.packageId, metaPath, "legacy");
+    if (packageCollision !== void 0) return packErr(packageCollision);
     capture?.declarations.set(metaPath, {
       format: "meta.json",
       sourcePath: metaPath,
@@ -8898,11 +9595,7 @@ async function scanValidated(roots, opts = {}, capture) {
         );
       }
     }
-    const sourceResolved = resolveAssetSource(metaPath, metaObj.source, assetPaths);
-    if (!sourceResolved.ok) {
-      return packErr(sourceResolved.error);
-    }
-    const expectedSourcePath = sourceResolved.value;
+    const expectedSourcePath = resolveAssetSource(metaPath, metaObj.source);
     try {
       await stat(expectedSourcePath);
     } catch {
@@ -8922,23 +9615,24 @@ async function scanValidated(roots, opts = {}, capture) {
       return packErr(
         makePackError("pack-malformed-meta", {
           path: sourcePath,
-          ajvErrors: [{ instancePath: "", message: "ScriptablePack source read failed" }]
+          ajvErrors: [{ instancePath: "", message: "Pack source read failed" }]
         })
       );
     }
-    const loaded = await loadScriptablePack(sourcePath, {
+    const loaderOptions = {
       ...opts.scriptablePack ?? {},
       ...capture === void 0 ? { metadataOnly: true } : {}
-    });
+    };
+    const loaded = await loadParameterizedScriptablePack(sourcePath, loaderOptions);
     if (!loaded.ok) {
-      const diagnostic = "diagnostic" in loaded.error.detail ? loaded.error.detail.diagnostic : void 0;
+      const diagnostic = loaded.error.detail.diagnostic;
       return packErr(
         makePackError("pack-malformed-meta", {
           path: sourcePath,
           ajvErrors: [
             {
               instancePath: "",
-              message: diagnostic === void 0 ? loaded.error.code : `${loaded.error.code}: ${diagnostic}`
+              message: typeof diagnostic === "string" ? `${loaded.error.code}: ${diagnostic}` : loaded.error.code
             }
           ]
         })
@@ -8951,41 +9645,81 @@ async function scanValidated(roots, opts = {}, capture) {
       return packErr(
         makePackError("pack-malformed-meta", {
           path: sourcePath,
-          ajvErrors: [{ instancePath: "", message: "ScriptablePack source closure read failed" }]
-        })
-      );
-    }
-    const meta = projectScriptablePackMeta(loaded.value, sourcePath);
-    const topology = validateProducerOutputs(meta.subAssets);
-    if (!topology.ok) {
-      return packErr(
-        makePackError("pack-malformed-meta", {
-          path: sourcePath,
-          ajvErrors: [{ instancePath: "/subAssets", message: topology.error.code }]
+          ajvErrors: [{ instancePath: "", message: "Pack source closure read failed" }]
         })
       );
     }
-    const declaration = {
+    const packageCollision = registerPackage(
+      PackageId.format(loaded.value.packageId),
+      sourcePath,
+      "parameterized"
+    );
+    if (packageCollision !== void 0) return packErr(packageCollision);
+    const meta = projectParameterizedPackMeta(loaded.value, sourcePath);
+    capture?.declarations.set(sourcePath, {
+      format: "pack.ts-parameterized",
       sourcePath,
       sourceRevision: `sha256:${createHash("sha256").update(source).digest("hex")}`,
-      meta,
+      value: meta,
       definition: loaded.value,
       sourceClosure
-    };
-    capture?.declarations.set(sourcePath, {
-      format: "pack.ts",
-      ...declaration,
-      value: meta
     });
-    for (const sub of meta.subAssets) {
-      const guid = sub.guid.toLowerCase();
-      const existing = guidToPath.get(guid);
-      if (existing !== void 0) {
+  }
+  const parentByPackageId = new Map(
+    instanceParents.map((instance) => [instance.packageId.toLowerCase(), instance])
+  );
+  for (const instance of instanceParents) {
+    const parentId = instance.parent.toLowerCase();
+    const parentPath = packageIdToPath.get(parentId);
+    if (parentPath === void 0) {
+      return packErr(
+        makePackError("pack-malformed-pack", {
+          path: instance.path,
+          reason: "pack-parent-not-found",
+          ajvErrors: [
+            {
+              instancePath: "/parent",
+              message: `parent packageId ${instance.parent} was not found`
+            }
+          ]
+        })
+      );
+    }
+    const kind = packageKind.get(parentId);
+    if (kind !== "parameterized" && kind !== "instance") {
+      return packErr(
+        makePackError("pack-malformed-pack", {
+          path: instance.path,
+          reason: "pack-parent-not-parameterized",
+          ajvErrors: [
+            {
+              instancePath: "/parent",
+              message: `parent ${instance.parent} is not a parameterized Pack`
+            }
+          ]
+        })
+      );
+    }
+  }
+  for (const instance of instanceParents) {
+    const chain = /* @__PURE__ */ new Set();
+    let current = instance.packageId.toLowerCase();
+    while (true) {
+      if (chain.has(current)) {
         return packErr(
-          makePackError("pack-guid-collision", { paths: [existing, sourcePath], guid })
+          makePackError("pack-malformed-pack", {
+            path: instance.path,
+            reason: "pack-parent-cycle",
+            ajvErrors: [
+              { instancePath: "/parent", message: `parent chain repeats packageId ${current}` }
+            ]
+          })
         );
       }
-      guidToPath.set(guid, sourcePath);
+      chain.add(current);
+      const next = parentByPackageId.get(current);
+      if (next === void 0) break;
+      current = next.parent.toLowerCase();
     }
   }
   const visited = /* @__PURE__ */ new Set();
@@ -9029,6 +9763,38 @@ async function scanInventory(roots, opts = {}) {
   for (const sourcePath of scanned.value) {
     const declaration = declarations.get(sourcePath);
     if (declaration?.format !== "pack.json") continue;
+    if (declaration.value.schemaVersion === "3.0.0") {
+      const parsed = parseParameterizedPackJson(declaration.value);
+      if (!parsed.ok) {
+        return packErr(
+          makePackError("pack-malformed-pack", {
+            path: sourcePath,
+            ajvErrors: [{ instancePath: "", message: parsed.error.code }]
+          })
+        );
+      }
+      if (parsed.value.format !== "direct") continue;
+      const projected = projectDirectPackJson(parsed.value);
+      if (!projected.ok) {
+        return packErr(
+          makePackError("pack-malformed-pack", {
+            path: sourcePath,
+            ajvErrors: [{ instancePath: "/assets", message: projected.error.code }]
+          })
+        );
+      }
+      for (const [index, asset] of projected.value.assets.entries()) {
+        inventory.push({
+          guid: asset.guid,
+          kind: asset.kind,
+          sourcePath,
+          sourceRevision: declaration.sourceRevision,
+          sourceKey: asset.sourceKey,
+          sourceIndex: index
+        });
+      }
+      continue;
+    }
     for (const [index, asset] of declaration.value.assets.entries()) {
       inventory.push({
         guid: asset.guid,
@@ -9070,28 +9836,18 @@ function unsupportedPolicyError(path, importer, policy) {
     subjects: [path]
   };
 }
-function projectMeta(rawPath, cwd, base, assetPaths, importerPolicy, sourceDeclaration, sourceIdentityFor) {
+function projectMeta(rawPath, cwd, base, importerPolicy, sourceDeclaration, sourceIdentityFor) {
   const meta = sourceDeclaration.value;
   const policy = importerPolicy(meta.importer);
   if (policy.disposition !== "publish") {
     return { entries: [], error: unsupportedPolicyError(rawPath, meta.importer, policy) };
   }
-  const resolved = resolveAssetSource(rawPath, meta.source, assetPaths);
-  if (!resolved.ok) {
-    return {
-      entries: [],
-      error: {
-        code: "catalog-meta-schema-invalid",
-        path: rawPath,
-        message: `source resolution failed: ${resolved.error.code} - ${resolved.error.hint}`
-      }
-    };
-  }
-  const sourcePath = catalogSourcePathFor(cwd, resolved.value, sourceIdentityFor);
+  const resolved = resolveAssetSource(rawPath, meta.source);
+  const sourcePath = catalogSourcePathFor(cwd, resolved, sourceIdentityFor);
   const packageUrl2 = `${base}/__forgeax-ddc/${meta.subAssets[0]?.guid?.toLowerCase() ?? "pack"}.pack.json`;
   const declaration = {
     importer: meta.importer,
-    source: resolved.value,
+    source: resolved,
     sourceRevision: sourceDeclaration.sourceRevision,
     ...meta.packageId === void 0 ? {} : { packageId: meta.packageId },
     ...meta.provenance === void 0 ? {} : { provenance: meta.provenance },
@@ -9125,23 +9881,13 @@ function projectMeta(rawPath, cwd, base, assetPaths, importerPolicy, sourceDecla
       sourcePath,
       packageUrl2,
       meta.subAssets,
-      (output) => deriveAssetName(resolved.value, meta.subAssets.length, output.name)
+      (output) => deriveAssetName(resolved, meta.subAssets.length, output.name)
     )
   };
 }
-function projectSource(path, cwd, base, assetPaths, importerPolicy, visibility, sourceDeclaration, declarations, sourceIdentityFor) {
-  if (sourceDeclaration.format === "pack.ts") {
-    const meta = { ...sourceDeclaration.meta, source: sourcePathFor(cwd, path) };
-    const anchorGuid = meta.subAssets.map((asset) => asset.guid.toLowerCase()).sort()[0];
-    return anchorGuid === void 0 ? { entries: [] } : {
-      entries: projectExternalCatalogEntries(
-        meta,
-        catalogSourcePathFor(cwd, path, sourceIdentityFor),
-        `${base}/__forgeax-ddc/${anchorGuid}.pack.json`,
-        meta.subAssets,
-        (output) => deriveAssetName(path, meta.subAssets.length, output.name)
-      )
-    };
+function projectSource(path, cwd, base, importerPolicy, visibility, sourceDeclaration, declarations, sourceIdentityFor) {
+  if (sourceDeclaration.format === "pack.ts-parameterized") {
+    return { entries: [] };
   }
   if (sourceDeclaration.format === "meta.json") {
     const policy = importerPolicy(sourceDeclaration.value.importer);
@@ -9156,7 +9902,6 @@ function projectSource(path, cwd, base, assetPaths, importerPolicy, visibility,
       path,
       cwd,
       base,
-      assetPaths,
       importerPolicy,
       sourceDeclaration,
       sourceIdentityFor
@@ -9166,6 +9911,57 @@ function projectSource(path, cwd, base, assetPaths, importerPolicy, visibility,
   }
   const parsed = sourceDeclaration.value;
   const sourcePath = catalogSourcePathFor(cwd, path, sourceIdentityFor);
+  if (parsed.schemaVersion === "3.0.0") {
+    const authoring = parseParameterizedPackJson(parsed);
+    if (!authoring.ok) {
+      return {
+        entries: [],
+        error: {
+          code: "catalog-meta-schema-invalid",
+          path,
+          message: `v3 Pack parse failed: ${authoring.error.code}`,
+          expected: "a valid direct or instance v3 Pack document",
+          actual: authoring.error.code,
+          hint: authoring.error.hint,
+          subjects: [path]
+        }
+      };
+    }
+    if (authoring.value.format !== "direct") return { entries: [] };
+    const projected = projectDirectPackJson(authoring.value);
+    if (!projected.ok) {
+      return {
+        entries: [],
+        error: {
+          code: "catalog-meta-schema-invalid",
+          path,
+          message: `v3 Pack projection failed: ${projected.error.code}`,
+          expected: "direct v3 assets to derive stable AssetGuids",
+          actual: projected.error.code,
+          hint: projected.error.hint,
+          subjects: [path]
+        }
+      };
+    }
+    const provenance2 = { provider: "pack", version: "3.0.0" };
+    return {
+      entries: projectPackageCatalog(
+        projected.value.assets.map((asset, sourceIndex) => ({
+          guid: asset.guid,
+          kind: asset.kind,
+          sourcePath,
+          sourceIndex,
+          sourceKey: asset.sourceKey,
+          refs: asset.refs,
+          execution: "direct",
+          packageId: projected.value.packageId,
+          provenance: provenance2,
+          name: deriveAssetName(path, projected.value.assets.length, asset.name)
+        })),
+        `${base}/${sourcePath}`
+      )
+    };
+  }
   const provenance = parsed.provenance ?? { provider: "pack", version: parsed.schemaVersion };
   return {
     entries: projectPackageCatalog(
@@ -9216,7 +10012,6 @@ async function buildCatalogProjection(roots, options) {
     return empty("degraded", [error]);
   }
   const { paths, declarations: sourceDeclarations } = scanned.value;
-  const { paths: assetPaths } = loadAssetConfig(cwd);
   const entries = [];
   const errors = [];
   const declarations = /* @__PURE__ */ new Map();
@@ -9227,7 +10022,6 @@ async function buildCatalogProjection(roots, options) {
       path,
       cwd,
       base,
-      assetPaths,
       options.importerPolicy,
       options.visibility,
       sourceDeclaration,
@@ -9389,13 +10183,13 @@ function topologyGroups(rows) {
   }
   return groups;
 }
-function revisionDiagnostic(code, expected, actual2, hint, rootId) {
+function revisionDiagnostic(code, expected, actual, hint, rootId) {
   return {
     code,
     severity: "blocking",
     authority: "catalog",
     expected,
-    actual: actual2,
+    actual,
     hint,
     ...rootId === void 0 ? {} : { subject: { type: "package", id: rootId } }
   };
@@ -9521,7 +10315,9 @@ function textureValues(values, textureFields) {
 }
 function collectMaterialCookRefs(material) {
   const textureFields = material.parameters === void 0 ? new Set(MATERIAL_TEXTURE_SLOTS) : new Set(
-    material.parameters.filter((parameter) => parameter.type === "texture").map((parameter) => parameter.name)
+    material.parameters.filter(
+      (parameter) => parameter.type === "texture" || parameter.type === "texture_cube"
+    ).map((parameter) => parameter.name)
   );
   const textures = textureValues(material.values, textureFields);
   return {
@@ -9555,20 +10351,20 @@ function jsonValue(value) {
   }
   return value;
 }
-function serializeCookedMaterialRecord(record) {
-  return JSON.stringify(jsonValue(record));
+function serializeCookedMaterialRecord(record2) {
+  return JSON.stringify(jsonValue(record2));
 }
 function serializeMaterialCookReceipt(receipt) {
   return JSON.stringify(jsonValue({ ...receipt, sourceClosure: unique(receipt.sourceClosure) }));
 }
-function invalid2(field, actual2) {
+function invalid(field, actual) {
   return err({
     code: "material-cook-record-invalid",
     expected: "a complete material-cook/3 record with layered identity and provenance",
     hint: "re-cook the material and publish its record, artifact, references, and receipt together",
     detail: {
       field,
-      ...actual2 === void 0 ? {} : { actual: actual2 },
+      ...actual === void 0 ? {} : { actual },
       action: "inspect the named field and recook the material generation"
     }
   });
@@ -9589,25 +10385,25 @@ function isGeneration(value) {
   return typeof value === "number" && Number.isSafeInteger(value) && value >= 1;
 }
 function validateIdentity(value) {
-  if (value === null || typeof value !== "object") return invalid2("receipt.identity", value);
+  if (value === null || typeof value !== "object") return invalid("receipt.identity", value);
   const candidate = value;
   for (const field of IDENTITY_FIELDS) {
     if (typeof candidate[field] !== "string" || candidate[field].length === 0) {
-      return invalid2(`receipt.identity.${field}`, candidate[field]);
+      return invalid(`receipt.identity.${field}`, candidate[field]);
     }
   }
   if (candidate.wasm === null || typeof candidate.wasm !== "object") {
-    return invalid2("receipt.identity.wasm", candidate.wasm);
+    return invalid("receipt.identity.wasm", candidate.wasm);
   }
   const wasm = candidate.wasm;
   for (const field of ["sourceContentKey", "artifactSha256", "glueSha256"]) {
     if (typeof wasm[field] !== "string" || wasm[field].length === 0) {
-      return invalid2(`receipt.identity.wasm.${field}`, wasm[field]);
+      return invalid(`receipt.identity.wasm.${field}`, wasm[field]);
     }
   }
   for (const field of ["valueGeneration", "dependencyGeneration", "cookGeneration"]) {
     if (!isGeneration(candidate[field]))
-      return invalid2(`receipt.identity.${field}`, candidate[field]);
+      return invalid(`receipt.identity.${field}`, candidate[field]);
   }
   return ok({
     ...candidate,
@@ -9615,38 +10411,38 @@ function validateIdentity(value) {
   });
 }
 function validateMaterialCookReceipt(value, expected = {}) {
-  if (value === null || typeof value !== "object") return invalid2("receipt");
+  if (value === null || typeof value !== "object") return invalid("receipt");
   const candidate = value;
   if (candidate.schemaVersion !== "material-cook/3")
-    return invalid2("receipt.schemaVersion", candidate.schemaVersion);
+    return invalid("receipt.schemaVersion", candidate.schemaVersion);
   const identityResult = validateIdentity(candidate.identity);
   if (!identityResult.ok) return identityResult;
   const identity = identityResult.value;
   if (candidate.derivedInterface === null || typeof candidate.derivedInterface !== "object") {
-    return invalid2("receipt.derivedInterface", candidate.derivedInterface);
+    return invalid("receipt.derivedInterface", candidate.derivedInterface);
   }
   const derivedInterface = candidate.derivedInterface;
   if (derivedInterface.layoutIdentity !== identity.layoutIdentity) {
-    return invalid2("receipt.derivedInterface.layoutIdentity", derivedInterface.layoutIdentity);
+    return invalid("receipt.derivedInterface.layoutIdentity", derivedInterface.layoutIdentity);
   }
   for (const field of ["sourceClosure", "profile", "compilerVersion"]) {
     const fieldValue = candidate[field];
     if (field === "sourceClosure" && !Array.isArray(fieldValue) || field !== "sourceClosure" && typeof fieldValue !== "string") {
-      return invalid2(`receipt.${field}`, fieldValue);
+      return invalid(`receipt.${field}`, fieldValue);
     }
   }
   const sourceClosure = candidate.sourceClosure;
   if (Array.isArray(sourceClosure) && sourceClosure.some((path) => typeof path !== "string")) {
-    return invalid2("receipt.sourceClosure", sourceClosure);
+    return invalid("receipt.sourceClosure", sourceClosure);
   }
   if (expected.layoutIdentity !== void 0 && identity.layoutIdentity !== expected.layoutIdentity) {
-    return invalid2("receipt.identity.layoutIdentity", identity.layoutIdentity);
+    return invalid("receipt.identity.layoutIdentity", identity.layoutIdentity);
   }
   if (expected.artifactDigest !== void 0 && identity.artifactDigest !== expected.artifactDigest) {
-    return invalid2("receipt.identity.artifactDigest", identity.artifactDigest);
+    return invalid("receipt.identity.artifactDigest", identity.artifactDigest);
   }
   if (expected.inputDigest !== void 0 && identity.cookIdentity !== expected.inputDigest) {
-    return invalid2("receipt.identity.cookIdentity", identity.cookIdentity);
+    return invalid("receipt.identity.cookIdentity", identity.cookIdentity);
   }
   return ok({
     schemaVersion: "material-cook/3",
@@ -9658,49 +10454,49 @@ function validateMaterialCookReceipt(value, expected = {}) {
   });
 }
 function validateCookedMaterialRecord(value) {
-  if (value === null || typeof value !== "object") return invalid2("record");
+  if (value === null || typeof value !== "object") return invalid("record");
   const candidate = value;
   if (candidate.schemaVersion !== "material-cook/3")
-    return invalid2("schemaVersion", candidate.schemaVersion);
-  if (typeof candidate.guid !== "string" || !candidate.guid) return invalid2("guid");
+    return invalid("schemaVersion", candidate.schemaVersion);
+  if (typeof candidate.guid !== "string" || !candidate.guid) return invalid("guid");
   if (candidate.materialGuid !== void 0 && typeof candidate.materialGuid !== "string")
-    return invalid2("materialGuid");
+    return invalid("materialGuid");
   if (candidate.publicationGeneration !== void 0 && !isGeneration(candidate.publicationGeneration))
-    return invalid2("publicationGeneration", candidate.publicationGeneration);
+    return invalid("publicationGeneration", candidate.publicationGeneration);
   if (candidate.specializationKey !== void 0 && typeof candidate.specializationKey !== "string")
-    return invalid2("specializationKey");
+    return invalid("specializationKey");
   if (candidate.artifactDigest !== void 0 && typeof candidate.artifactDigest !== "string")
-    return invalid2("artifactDigest");
+    return invalid("artifactDigest");
   if (candidate.sourceClosure !== void 0 && (!Array.isArray(candidate.sourceClosure) || candidate.sourceClosure.some((path) => typeof path !== "string")))
-    return invalid2("sourceClosure");
+    return invalid("sourceClosure");
   if (candidate.parameterContract !== void 0) {
     if (candidate.parameterContract === null || typeof candidate.parameterContract !== "object")
-      return invalid2("parameterContract");
+      return invalid("parameterContract");
     const parameterContract = candidate.parameterContract;
     if (!Array.isArray(parameterContract.parameters))
-      return invalid2("parameterContract.parameters");
+      return invalid("parameterContract.parameters");
     if (parameterContract.values === null || typeof parameterContract.values !== "object" || Array.isArray(parameterContract.values))
-      return invalid2("parameterContract.values");
+      return invalid("parameterContract.values");
   }
   if (candidate.resolved === null || typeof candidate.resolved !== "object")
-    return invalid2("resolved");
-  if (candidate.refs === null || typeof candidate.refs !== "object") return invalid2("refs");
+    return invalid("resolved");
+  if (candidate.refs === null || typeof candidate.refs !== "object") return invalid("refs");
   if (candidate.artifact === null || typeof candidate.artifact !== "object")
-    return invalid2("artifact");
+    return invalid("artifact");
   if (candidate.receipt === null || typeof candidate.receipt !== "object")
-    return invalid2("receipt");
+    return invalid("receipt");
   const artifact = candidate.artifact;
   if (typeof artifact.digest !== "string" || !Array.isArray(artifact.bytes) && !ArrayBuffer.isView(artifact.bytes)) {
-    return invalid2("artifact");
+    return invalid("artifact");
   }
   const receiptResult = validateMaterialCookReceipt(candidate.receipt, {
     artifactDigest: artifact.digest
   });
   if (!receiptResult.ok) return receiptResult;
   if (candidate.artifactDigest !== void 0 && candidate.artifactDigest !== artifact.digest)
-    return invalid2("artifactDigest", candidate.artifactDigest);
+    return invalid("artifactDigest", candidate.artifactDigest);
   if (candidate.publicationGeneration !== void 0 && receiptResult.value.identity.cookGeneration !== candidate.publicationGeneration)
-    return invalid2("receipt.identity.cookGeneration", receiptResult.value.identity.cookGeneration);
+    return invalid("receipt.identity.cookGeneration", receiptResult.value.identity.cookGeneration);
   const normalized = {
     ...candidate,
     artifact: {
@@ -9711,13 +10507,13 @@ function validateCookedMaterialRecord(value) {
   };
   return ok(normalized);
 }
-function projectCookedMaterialRecord(record) {
+function projectCookedMaterialRecord(record2) {
   return {
-    resolved: record.resolved,
-    refs: record.refs,
-    artifact: record.artifact,
-    receipt: record.receipt,
-    schemaVersion: record.schemaVersion
+    resolved: record2.resolved,
+    refs: record2.refs,
+    artifact: record2.artifact,
+    receipt: record2.receipt,
+    schemaVersion: record2.schemaVersion
   };
 }
 function packageEvidence(input) {
@@ -9760,12 +10556,150 @@ function packageVerification(input) {
   };
 }
 
+// src/inventory/binding.ts
+function projectAssetRefs(inventory) {
+  return inventory.declarations.map(
+    (row) => ({
+      guid: row.guid,
+      sourceKey: row.sourceKey,
+      kind: row.kind
+    })
+  );
+}
+function projectSceneEntityRefs(inventory) {
+  return inventory.declarations.flatMap(
+    (row) => row.sceneBindings === void 0 ? [] : row.sceneBindings.map((bindingKey) => ({
+      sceneSourceKey: row.sourceKey,
+      bindingKey
+    }))
+  );
+}
+function failure2(code, expected, hint, detail) {
+  return err({ code, expected, hint, detail });
+}
+function validateAuthorInventory(value) {
+  if (typeof value !== "object" || value === null || !Array.isArray(value.declarations)) {
+    return failure2(
+      "inventory-source-key-missing",
+      "an author inventory with declaration rows",
+      "declare each author asset in the source inventory",
+      {}
+    );
+  }
+  const guids = /* @__PURE__ */ new Set();
+  const sourceKeys = /* @__PURE__ */ new Set();
+  const declarations = [];
+  const rows = value.declarations;
+  for (const raw of rows) {
+    if (typeof raw !== "object" || raw === null) {
+      return failure2(
+        "inventory-source-key-missing",
+        "each declaration has a non-empty sourceKey",
+        "add sourceKey to the author declaration before projection",
+        {}
+      );
+    }
+    const row = raw;
+    const guid = typeof row.guid === "string" ? row.guid : void 0;
+    const sourceKey2 = typeof row.sourceKey === "string" ? row.sourceKey : void 0;
+    if (guid === void 0 || sourceKey2 === void 0 || sourceKey2.trim().length === 0 || sourceKey2 !== sourceKey2.trim()) {
+      return failure2(
+        "inventory-source-key-missing",
+        "each declaration has a non-empty sourceKey",
+        "add sourceKey to the author declaration before projection",
+        {
+          ...guid === void 0 ? {} : { guid },
+          ...sourceKey2 === void 0 ? {} : { sourceKey: sourceKey2 }
+        }
+      );
+    }
+    const normalizedGuid = guid.toLowerCase();
+    if (guids.has(normalizedGuid)) {
+      return failure2(
+        "inventory-guid-duplicate",
+        "every GUID identifies exactly one author declaration",
+        "remove or rename the duplicate GUID before publishing the inventory",
+        { guid, sourceKey: sourceKey2 }
+      );
+    }
+    if (sourceKeys.has(sourceKey2)) {
+      return failure2(
+        "inventory-source-key-duplicate",
+        "every sourceKey identifies exactly one author declaration",
+        "rename the duplicate semantic sourceKey before publishing the inventory",
+        { guid, sourceKey: sourceKey2 }
+      );
+    }
+    if (row.kind === "scene") {
+      const payload = row.payload;
+      const payloadRecord = typeof payload === "object" && payload !== null ? payload : void 0;
+      const entities = payloadRecord !== void 0 && Array.isArray(payloadRecord.entities) ? payloadRecord.entities : [];
+      const bindings = /* @__PURE__ */ new Set();
+      for (const entity of entities) {
+        const bindingKey = typeof entity === "object" && entity !== null && typeof entity.bindingKey === "string" ? entity.bindingKey : void 0;
+        if (bindingKey !== void 0 && bindingKey.length === 0) {
+          return failure2(
+            "inventory-scene-binding-missing",
+            "each declared scene bindingKey is non-empty",
+            "remove the empty bindingKey or declare a stable key in the scene producer",
+            { sourceKey: sourceKey2 }
+          );
+        }
+        if (bindingKey === void 0) continue;
+        if (bindings.has(bindingKey)) {
+          return failure2(
+            "inventory-scene-binding-duplicate",
+            "bindingKey values are unique within one scene",
+            "rename the duplicate bindingKey in the scene producer",
+            { sourceKey: sourceKey2 }
+          );
+        }
+        bindings.add(bindingKey);
+      }
+    }
+    guids.add(normalizedGuid);
+    sourceKeys.add(sourceKey2);
+    const sceneBindings = row.kind === "scene" && typeof row.payload === "object" && row.payload !== null ? row.payload.entities?.flatMap(
+      (entity) => {
+        if (typeof entity !== "object" || entity === null) return [];
+        const key = entity.bindingKey;
+        return typeof key === "string" && key.length > 0 ? [key] : [];
+      }
+    ) : void 0;
+    declarations.push({
+      guid,
+      sourceKey: sourceKey2,
+      kind: typeof row.kind === "string" ? row.kind : "unknown",
+      payload: typeof row.payload === "object" && row.payload !== null ? row.payload : {},
+      refs: Array.isArray(row.refs) ? row.refs.filter((ref) => typeof ref === "string") : [],
+      ...sceneBindings === void 0 ? {} : { sceneBindings }
+    });
+  }
+  return ok({ declarations });
+}
+
+// src/inventory/sync.ts
+function inventoryDigest(inventory) {
+  return inventory.declarations.map(
+    (row) => `${row.guid}\0${row.sourceKey}\0${row.kind}\0${row.sceneBindings?.join("\0") ?? ""}`
+  ).sort().join("\n");
+}
+function syncAuthorInventory(inventory) {
+  return {
+    declarations: inventory.declarations.map((row) => ({
+      ...row,
+      refs: [...row.refs],
+      ...row.sceneBindings === void 0 ? {} : { sceneBindings: [...row.sceneBindings] }
+    }))
+  };
+}
+
 // src/mesh-bin-contract.ts
 var MESH_BIN_VERSION = 4;
 var MESH_BIN_PROJECTION_VERSION = 1;
 var MESH_BIN_HEADER_V4_BYTES = 80;
 var MESH_BIN_DIGEST_BYTES = 32;
-function failure(code, sourceKey2, expected, actual2) {
+function failure3(code, sourceKey2, expected, actual) {
   return {
     ok: false,
     error: {
@@ -9773,7 +10707,7 @@ function failure(code, sourceKey2, expected, actual2) {
       subject: "mesh-bin",
       sourceKey: sourceKey2,
       expected,
-      actual: actual2,
+      actual,
       recovery: "re-cook the source with its Meta sidecar through the build-time importer"
     }
   };
@@ -9805,7 +10739,7 @@ function writeMeshBinHeader(header, out) {
 }
 function decodeMeshBinHeader(bytes, sourceKey2 = "<unknown mesh source>") {
   if (bytes.byteLength < MESH_BIN_HEADER_V4_BYTES) {
-    return failure(
+    return failure3(
       "mesh-bin-header-truncated",
       sourceKey2,
       `mesh-bin v4 header (${MESH_BIN_HEADER_V4_BYTES} bytes)`,
@@ -9815,7 +10749,7 @@ function decodeMeshBinHeader(bytes, sourceKey2 = "<unknown mesh source>") {
   const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
   const version = view.getUint32(0, true);
   if (version !== MESH_BIN_VERSION) {
-    return failure("mesh-bin-version-unsupported", sourceKey2, "mesh-bin v4", `version ${version}`);
+    return failure3("mesh-bin-version-unsupported", sourceKey2, "mesh-bin v4", `version ${version}`);
   }
   const projectionVersion = view.getUint32(4, true);
   const mask = view.getUint32(8, true);
@@ -9828,7 +10762,7 @@ function decodeMeshBinHeader(bytes, sourceKey2 = "<unknown mesh source>") {
   const jsonBytes = view.getUint32(36, true);
   const digest3 = readDigest(bytes.subarray(48, 48 + MESH_BIN_DIGEST_BYTES));
   if (projectionVersion !== MESH_BIN_PROJECTION_VERSION || mask === 0 || stride === 0 || !Number.isSafeInteger(vertexCount) || !Number.isSafeInteger(vertexBytes) || !Number.isSafeInteger(indexCount) || !Number.isSafeInteger(indexBytes) || !Number.isSafeInteger(jsonBytes) || indexCount === 0 && indexWidth !== 0 || indexCount > 0 && indexWidth !== 2 && indexWidth !== 4 || indexBytes !== indexCount * indexWidth || vertexBytes !== vertexCount * stride || digest3.length === 0) {
-    return failure(
+    return failure3(
       "mesh-bin-header-invalid",
       sourceKey2,
       "safe v4 projection, stride, cardinality, and payload byte lengths",
@@ -9852,24 +10786,7 @@ function decodeMeshBinHeader(bytes, sourceKey2 = "<unknown mesh source>") {
     }
   };
 }
-function upgradeLegacyAuthoredPack(pack) {
-  if (pack.schemaVersion !== "1.0.0" || pack.assets === void 0) return pack;
-  return {
-    ...pack,
-    schemaVersion: "2.0.0",
-    assets: pack.assets.map((asset) => {
-      const fontRefs = asset.kind === "font" ? [asset.payload.atlasGuid, asset.payload.samplerGuid].filter(
-        (guid) => typeof guid === "string"
-      ) : [];
-      return {
-        ...asset,
-        refs: asset.refs ?? fontRefs,
-        artifacts: asset.artifacts ?? {}
-      };
-    })
-  };
-}
-function failure2(code, expected, hint, detail) {
+function failure4(code, expected, hint, detail) {
   return { ok: false, error: { code, expected, hint, detail } };
 }
 function sorted(value) {
@@ -9968,7 +10885,7 @@ function transportArtifacts(assets, artifactPath) {
 }
 async function finalizePackageProduct(product, policy) {
   if (product.sourceRevision.trim().length === 0) {
-    return failure2(
+    return failure4(
       "missing-source-revision",
       "a non-empty source revision",
       "rebuild the inventory and provide the producer source revision",
@@ -9979,7 +10896,7 @@ async function finalizePackageProduct(product, policy) {
   for (const asset of product.assets) {
     const guid = asset.guid.toLowerCase();
     if (seen.has(guid)) {
-      return failure2(
+      return failure4(
         "duplicate-guid",
         "one terminal product row per GUID",
         "repair the inventory or producer output before finalization",
@@ -9989,7 +10906,7 @@ async function finalizePackageProduct(product, policy) {
     seen.add(guid);
     for (const [key, artifact] of Object.entries(asset.artifacts)) {
       if (!safePath(key) || !(artifact.bytes instanceof Uint8Array)) {
-        return failure2(
+        return failure4(
           "invalid-artifact",
           "asset-local artifact keys and byte bodies",
           "repair the producer artifact before finalization",
@@ -10000,7 +10917,7 @@ async function finalizePackageProduct(product, policy) {
   }
   for (const guid of seen) {
     if (!product.receipts.some((receipt) => receipt.guid.toLowerCase() === guid)) {
-      return failure2(
+      return failure4(
         "missing-receipt",
         "one receipt for every terminal product GUID",
         "preserve the producer receipt when handing the product to engine-pack",
@@ -10016,7 +10933,7 @@ async function finalizePackageProduct(product, policy) {
       for (const [key, artifact] of Object.entries(asset.artifacts)) {
         const path = policy.artifactPath(asset.guid, key);
         if (!safePath(path)) {
-          return failure2(
+          return failure4(
             "invalid-artifact",
             "package-relative artifact output paths",
             "repair the finalizer artifact path policy",
@@ -10027,7 +10944,7 @@ async function finalizePackageProduct(product, policy) {
       }
     }
     if (!safePath(policy.packagePath)) {
-      return failure2(
+      return failure4(
         "invalid-artifact",
         "a package-relative package path",
         "repair the finalizer package path policy",
@@ -10070,6 +10987,7 @@ async function finalizePackageTransportSource(input, policy) {
     packageUrl: finalized.value.packageUrl,
     artifacts: transportArtifacts(product.assets, policy.artifactPath),
     digest: finalized.value.digest,
+    receipts: finalized.value.receipts,
     sourceRevision,
     semantic: JSON.stringify(sorted(finalized.value.pack))
   };
@@ -10092,6 +11010,1601 @@ function revisionStable(value) {
 function packageTransportRevision(value) {
   return createHash("sha256").update(JSON.stringify(revisionStable(value))).digest("hex");
 }
+function isRecord3(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function jsonValue2(value) {
+  if (value instanceof Uint8Array) return AssetGuid.format(value);
+  if (Array.isArray(value)) return value.map((item) => jsonValue2(item));
+  if (isRecord3(value)) {
+    return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, jsonValue2(item)]));
+  }
+  return value;
+}
+function revisionOf(source) {
+  return `sha256:${createHash("sha256").update(source).digest("hex")}`;
+}
+function makeError(code, expected, hint, detail = {}, actual) {
+  return {
+    code,
+    expected,
+    hint,
+    ...actual === void 0 ? {} : { actual },
+    detail
+  };
+}
+function pathError(code, operation, expected, hint, detail = {}, actual) {
+  return makeError(code, expected, hint, { requestId: operation.requestId, ...detail }, actual);
+}
+function confinedPath(gameRoot, candidate, operation) {
+  if (typeof candidate !== "string" || candidate.length === 0 || isAbsolute(candidate)) {
+    return err(
+      pathError(
+        "pack-source-path-invalid",
+        operation,
+        "a non-empty game-root-relative .pack.ts or .pack.json path",
+        "pass a relative source locator inside the selected game root",
+        { sourcePath: candidate },
+        typeof candidate === "string" ? candidate : void 0
+      )
+    );
+  }
+  const root = resolve(gameRoot);
+  const absolute = resolve(root, candidate);
+  const relativePath = relative(root, absolute).split(sep).join("/");
+  if (relativePath.length === 0 || relativePath === ".." || relativePath.startsWith("../") || !relativePath.endsWith(".pack.ts") && !relativePath.endsWith(".pack.json")) {
+    return err(
+      pathError(
+        "pack-source-path-invalid",
+        operation,
+        "a game-root-relative .pack.ts or .pack.json path",
+        "choose a Pack source path inside the selected game root",
+        { sourcePath: candidate },
+        candidate
+      )
+    );
+  }
+  return ok({ absolute, relative: relativePath });
+}
+async function atomicWrite(path, source) {
+  await mkdir(dirname(path), { recursive: true });
+  const temporary = `${path}.${process.pid}.${Date.now()}.tmp`;
+  try {
+    await writeFile(temporary, source, { encoding: "utf8", flag: "wx" });
+    await rename(temporary, path);
+  } catch (cause) {
+    await rm(temporary, { force: true });
+    throw cause;
+  }
+}
+function packageKey(packageId2) {
+  return PackageId.format(packageId2).toLowerCase();
+}
+function parsePackageId2(value) {
+  if (typeof value !== "string") return void 0;
+  const parsed = PackageId.parse(value);
+  return parsed.ok ? parsed.value : void 0;
+}
+function serializedParameters(definition) {
+  if (!("parameters" in definition)) return void 0;
+  return definition.parameters.map((parameter) => ({
+    name: parameter.name,
+    type: parameter.type,
+    default: jsonValue2(parameter.default),
+    ...parameter.minimum === void 0 ? {} : { minimum: parameter.minimum },
+    ...parameter.maximum === void 0 ? {} : { maximum: parameter.maximum },
+    ...parameter.values === void 0 ? {} : { values: parameter.values },
+    ...parameter.kind === void 0 ? {} : { kind: parameter.kind }
+  }));
+}
+function sourceResult(subject, operation) {
+  const base = {
+    operation: operation.operation,
+    requestId: operation.requestId,
+    sourcePath: subject.relativePath,
+    packageId: PackageId.format(subject.packageId),
+    format: subject.format === "source" ? "pack.ts" : subject.format
+  };
+  if (subject.format === "source") {
+    const parameters = serializedParameters(subject.definition);
+    return {
+      ...base,
+      ...parameters === void 0 ? {} : { parameters },
+      ...parameters === void 0 ? {} : {
+        capabilities: [
+          "asset-source.create-instance",
+          "asset-source.rebuild",
+          "asset-source.cold-cook"
+        ]
+      }
+    };
+  }
+  if (subject.format === "instance") {
+    return {
+      ...base,
+      parentPackageId: PackageId.format(subject.parent),
+      values: jsonValue2(subject.values)
+    };
+  }
+  return {
+    ...base,
+    assets: subject.assets.map((asset) => ({
+      sourceKey: asset.sourceKey,
+      guid: asset.guid,
+      kind: asset.kind,
+      ...asset.name === void 0 ? {} : { name: asset.name },
+      refs: asset.refs
+    }))
+  };
+}
+function scanFailure(operation, cause) {
+  const value = cause !== null && typeof cause === "object" ? cause : {};
+  const detail = value.detail !== null && typeof value.detail === "object" ? value.detail : {};
+  const reason = isRecord3(detail) && typeof detail.reason === "string" ? detail.reason : void 0;
+  const code = reason === "pack-parent-not-found" || reason === "pack-parent-cycle" || reason === "pack-parent-not-parameterized" ? reason : value.code === "pack-guid-collision" ? "pack-guid-collision" : "pack-parameter-invalid";
+  return makeError(
+    code,
+    typeof value.expected === "string" ? value.expected : "a valid Pack Source Index",
+    typeof value.hint === "string" ? value.hint : "repair the first source or package diagnostic, then retry",
+    { requestId: operation.requestId, cause: value.detail ?? String(cause) }
+  );
+}
+function scanRoots(options) {
+  return options.scanRoots === void 0 || options.scanRoots.length === 0 ? [resolve(options.gameRoot)] : options.scanRoots.map((root) => resolve(options.gameRoot, root));
+}
+async function readMaterialized(options, operation) {
+  let rawRows;
+  try {
+    rawRows = await options.materialized?.() ?? [];
+  } catch (cause) {
+    return err(
+      makeError(
+        "pack-parameter-invalid",
+        "the materialized projection callback to return current-generation rows",
+        "repair the build-owner projection callback, then retry the Pack operation",
+        {
+          requestId: operation.requestId,
+          cause: cause instanceof Error ? cause.message : String(cause)
+        }
+      )
+    );
+  }
+  if (!Array.isArray(rawRows)) {
+    return err(
+      makeError(
+        "pack-parameter-invalid",
+        "the materialized projection callback to return an array",
+        "repair the build-owner projection callback, then retry the Pack operation",
+        { requestId: operation.requestId, actual: typeof rawRows }
+      )
+    );
+  }
+  const materialized = [];
+  const pairOwners = /* @__PURE__ */ new Map();
+  const guidOwners = /* @__PURE__ */ new Map();
+  for (const rawRow of rawRows) {
+    if (!isRecord3(rawRow)) {
+      return err(
+        makeError(
+          "pack-parameter-invalid",
+          "materialized rows to be objects",
+          "repair the current generation projection before querying Pack authoring",
+          { requestId: operation.requestId, actual: typeof rawRow }
+        )
+      );
+    }
+    const row = rawRow;
+    const parsedPackageId = parsePackageId2(row.packageId);
+    if (parsedPackageId === void 0) {
+      return err(
+        makeError(
+          "pack-package-id-invalid",
+          "materialized rows to contain a valid UUID packageId",
+          "repair the current generation projection before querying Pack authoring",
+          { requestId: operation.requestId, packageId: row.packageId, sourceKey: row.sourceKey }
+        )
+      );
+    }
+    if (!isValidPackSourceKey(row.sourceKey)) {
+      return err(
+        makeError(
+          "pack-source-key-invalid",
+          "materialized rows to contain a valid sourceKey",
+          "repair the current generation projection before querying Pack authoring",
+          { requestId: operation.requestId, packageId: row.packageId, sourceKey: row.sourceKey }
+        )
+      );
+    }
+    if (typeof row.guid !== "string" || !isValidAssetGuidString(row.guid) || typeof row.kind !== "string" || row.kind.length === 0) {
+      return err(
+        makeError(
+          "pack-parameter-invalid",
+          "materialized rows to contain a valid GUID and non-empty kind",
+          "repair the current generation projection before querying Pack authoring",
+          { requestId: operation.requestId, packageId: row.packageId, sourceKey: row.sourceKey }
+        )
+      );
+    }
+    if (row.refs !== void 0 && (!Array.isArray(row.refs) || row.refs.some((ref) => typeof ref !== "string" || !isValidAssetGuidString(ref)))) {
+      return err(
+        makeError(
+          "pack-parameter-invalid",
+          "materialized refs to contain UUID AssetGuid strings when present",
+          "repair the current generation projection before querying Pack authoring",
+          { requestId: operation.requestId, packageId: row.packageId, sourceKey: row.sourceKey }
+        )
+      );
+    }
+    if (row.sourcePath !== void 0 && typeof row.sourcePath !== "string") {
+      return err(
+        makeError(
+          "pack-parameter-invalid",
+          "materialized sourcePath to be a string when present",
+          "repair the current generation projection before querying Pack authoring",
+          { requestId: operation.requestId, sourcePath: row.sourcePath }
+        )
+      );
+    }
+    const packageId2 = PackageId.format(parsedPackageId).toLowerCase();
+    const expectedGuid = AssetGuid.format(
+      AssetGuid.derive(parsedPackageId, row.sourceKey)
+    ).toLowerCase();
+    const guid = row.guid.toLowerCase();
+    if (guid !== expectedGuid) {
+      return err(
+        makeError(
+          "pack-guid-collision",
+          "materialized GUID to equal UUIDv5(packageId, sourceKey)",
+          "rebuild the current generation from the stable packageId and sourceKey pair",
+          {
+            requestId: operation.requestId,
+            packageId: packageId2,
+            sourceKey: row.sourceKey,
+            expectedGuid,
+            observedGuid: row.guid
+          }
+        )
+      );
+    }
+    const pair = `${packageId2}/${row.sourceKey}`;
+    const pairOwner = pairOwners.get(pair);
+    if (pairOwner !== void 0) {
+      return err(
+        makeError(
+          "pack-guid-collision",
+          "one materialized row per packageId/sourceKey pair",
+          "remove the stale duplicate row from the current generation projection",
+          { requestId: operation.requestId, pair, paths: [pairOwner, row.sourcePath] }
+        )
+      );
+    }
+    pairOwners.set(pair, row.sourcePath ?? pair);
+    const guidOwner = guidOwners.get(guid);
+    if (guidOwner !== void 0) {
+      return err(
+        makeError(
+          "pack-guid-collision",
+          "one materialized owner per derived AssetGuid",
+          "repair the current generation projection so each derived GUID has one owner",
+          { requestId: operation.requestId, guid, paths: [guidOwner, row.sourcePath] }
+        )
+      );
+    }
+    guidOwners.set(guid, row.sourcePath ?? pair);
+    materialized.push({
+      packageId: packageId2,
+      sourceKey: row.sourceKey,
+      guid,
+      kind: row.kind,
+      ...row.sourcePath === void 0 ? {} : { sourcePath: row.sourcePath },
+      ...row.refs === void 0 ? {} : { refs: Object.freeze([...row.refs]) },
+      ready: row.ready === true && row.artifactsReady !== false
+    });
+  }
+  materialized.sort(
+    (left, right) => `${left.packageId}/${left.sourceKey}`.localeCompare(`${right.packageId}/${right.sourceKey}`)
+  );
+  return ok(materialized);
+}
+async function createSnapshot(options, operation) {
+  const scanned = options.inventory === void 0 ? await scanInventory(scanRoots(options)) : await options.inventory();
+  if (!scanned.ok) return err(scanFailure(operation, scanned.error));
+  const subjects = /* @__PURE__ */ new Map();
+  const directAssets = [];
+  for (const [sourcePath, declaration] of scanned.value.declarations) {
+    const relativePath = relative(resolve(options.gameRoot), sourcePath).split(sep).join("/");
+    if (declaration.format === "pack.ts-parameterized") {
+      subjects.set(packageKey(declaration.definition.packageId), {
+        format: "source",
+        packageId: declaration.definition.packageId,
+        sourcePath,
+        relativePath,
+        definition: declaration.definition
+      });
+      continue;
+    }
+    if (declaration.format !== "pack.json" || declaration.value.schemaVersion !== "3.0.0") continue;
+    const parsed = parseParameterizedPackJson(declaration.value);
+    if (!parsed.ok) return err(parsed.error);
+    if (parsed.value.format === "direct") {
+      const projected = projectDirectPackJson(parsed.value);
+      if (!projected.ok) return err(projected.error);
+      const subject = {
+        format: "direct",
+        packageId: parsed.value.packageId,
+        sourcePath,
+        relativePath,
+        assets: projected.value.assets
+      };
+      subjects.set(packageKey(subject.packageId), subject);
+      directAssets.push(
+        ...projected.value.assets.map((asset) => ({
+          packageId: projected.value.packageId.toLowerCase(),
+          sourceKey: asset.sourceKey,
+          guid: asset.guid.toLowerCase(),
+          kind: asset.kind,
+          sourcePath: relativePath,
+          ...asset.name === void 0 ? {} : { name: asset.name },
+          refs: asset.refs
+        }))
+      );
+    } else {
+      subjects.set(packageKey(parsed.value.packageId), {
+        format: "instance",
+        packageId: parsed.value.packageId,
+        parent: parsed.value.parent,
+        values: parsed.value.values,
+        sourcePath,
+        relativePath
+      });
+    }
+  }
+  const materializedResult = await readMaterialized(options, operation);
+  if (!materializedResult.ok) return materializedResult;
+  const materialized = materializedResult.value;
+  const guidOwners = /* @__PURE__ */ new Map();
+  const directPairs = /* @__PURE__ */ new Set();
+  for (const entry of scanned.value.inventory) {
+    const declaration = scanned.value.declarations.get(entry.sourcePath);
+    if (declaration?.format === "pack.json" && declaration.value.schemaVersion === "3.0.0") {
+      continue;
+    }
+    guidOwners.set(entry.guid.toLowerCase(), entry.sourcePath);
+  }
+  for (const asset of directAssets) {
+    directPairs.add(`${asset.packageId}/${asset.sourceKey}`);
+    const existing = guidOwners.get(asset.guid);
+    if (existing !== void 0) {
+      return err(
+        makeError(
+          "pack-guid-collision",
+          "one current-generation owner per AssetGuid",
+          "repair the direct Pack or external source projection before querying Pack authoring",
+          {
+            requestId: operation.requestId,
+            guid: asset.guid,
+            paths: [existing, asset.sourcePath]
+          }
+        )
+      );
+    }
+    guidOwners.set(asset.guid, asset.sourcePath ?? asset.packageId);
+  }
+  for (const asset of materialized) {
+    const existing = guidOwners.get(asset.guid);
+    const pair = `${asset.packageId}/${asset.sourceKey}`;
+    if (existing !== void 0 && !directPairs.has(pair)) {
+      return err(
+        makeError(
+          "pack-guid-collision",
+          "one current-generation owner per AssetGuid",
+          "remove the stale materialized row or repair the direct/source owner before querying Pack authoring",
+          {
+            requestId: operation.requestId,
+            guid: asset.guid,
+            paths: [existing, asset.sourcePath]
+          }
+        )
+      );
+    }
+    guidOwners.set(asset.guid, asset.sourcePath ?? asset.packageId);
+  }
+  const knownGuids = /* @__PURE__ */ new Set([
+    ...scanned.value.inventory.map((entry) => entry.guid.toLowerCase()),
+    ...directAssets.map((asset) => asset.guid),
+    ...materialized.map((asset) => asset.guid)
+  ]);
+  return ok({ inventory: scanned.value, subjects, directAssets, materialized, knownGuids });
+}
+function parentSubject(snapshot, packageId2) {
+  const subject = snapshot.subjects.get(packageKey(packageId2));
+  if (subject === void 0) return void 0;
+  if (subject.format === "source") {
+    return {
+      format: "source",
+      packageId: subject.packageId,
+      parameters: "parameters" in subject.definition ? subject.definition.parameters : []
+    };
+  }
+  if (subject.format === "instance") {
+    return {
+      format: "instance",
+      packageId: subject.packageId,
+      parent: subject.parent,
+      values: subject.values
+    };
+  }
+  return { format: "direct", packageId: subject.packageId };
+}
+async function resolveInstance(snapshot, subject) {
+  return resolvePackParameterInheritance(
+    {
+      format: "instance",
+      packageId: subject.packageId,
+      parent: subject.parent,
+      values: subject.values
+    },
+    async (packageId2) => parentSubject(snapshot, packageId2)
+  );
+}
+function subjectFor(gameRoot, snapshot, operation) {
+  if (operation.sourcePath !== void 0) {
+    const confined = confinedPath(gameRoot, operation.sourcePath, operation);
+    if (!confined.ok) return confined;
+    const expected = confined.value.relative;
+    const source = [...snapshot.subjects.values()].find(
+      (candidate) => candidate.relativePath === expected
+    );
+    if (source !== void 0) {
+      const requestedPackageId = operation.packageId === void 0 ? void 0 : PackageId.parse(operation.packageId);
+      if (requestedPackageId?.ok === false) {
+        return err(
+          makeError(
+            "pack-package-id-invalid",
+            "a UUID packageId",
+            "repair packageId before querying the Pack subject",
+            { requestId: operation.requestId, packageId: operation.packageId },
+            operation.packageId
+          )
+        );
+      }
+      if (requestedPackageId?.ok === true && packageKey(requestedPackageId.value) !== packageKey(source.packageId)) {
+        return err(
+          makeError(
+            "pack-parameter-invalid",
+            "sourcePath and packageId to identify the same Pack subject",
+            "remove the conflicting locator or use the packageId returned by asset.list",
+            {
+              requestId: operation.requestId,
+              sourcePath: expected,
+              packageId: operation.packageId,
+              observedPackageId: PackageId.format(source.packageId)
+            }
+          )
+        );
+      }
+      return ok(source);
+    }
+    return err(
+      pathError(
+        "pack-source-not-found",
+        operation,
+        "sourcePath to identify a current Pack subject",
+        "inspect the current Source Index and choose an existing source path",
+        { sourcePath: expected },
+        expected
+      )
+    );
+  }
+  if (operation.packageId !== void 0) {
+    const parsed = PackageId.parse(operation.packageId);
+    if (!parsed.ok) {
+      return err(
+        makeError(
+          "pack-package-id-invalid",
+          "a UUID packageId",
+          "repair packageId before querying the Pack",
+          { requestId: operation.requestId, packageId: operation.packageId },
+          operation.packageId
+        )
+      );
+    }
+    const subject = snapshot.subjects.get(packageKey(parsed.value));
+    if (subject !== void 0) return ok(subject);
+    return err(
+      makeError(
+        "pack-source-not-found",
+        "packageId to exist in the current Source Index",
+        "inspect the current source index and choose an existing packageId",
+        { requestId: operation.requestId, packageId: operation.packageId }
+      )
+    );
+  }
+  if (operation.subject !== void 0 && !isValidAssetGuidString(operation.subject)) {
+    const confined = confinedPath(gameRoot, operation.subject, operation);
+    if (!confined.ok) return confined;
+    const source = [...snapshot.subjects.values()].find(
+      (candidate) => candidate.relativePath === confined.value.relative
+    );
+    if (source !== void 0) return ok(source);
+  }
+  if (operation.subject !== void 0 && isValidAssetGuidString(operation.subject)) {
+    const guid = operation.subject.toLowerCase();
+    const packageSubject = snapshot.subjects.get(guid);
+    if (packageSubject !== void 0) return ok(packageSubject);
+    const asset = [...snapshot.directAssets, ...snapshot.materialized].find(
+      (candidate) => candidate.guid === guid
+    );
+    if (asset !== void 0) {
+      const subject = snapshot.subjects.get(asset.packageId);
+      if (subject !== void 0) return ok(subject);
+    }
+  }
+  return err(
+    makeError(
+      "pack-source-not-found",
+      "a packageId, source path, or known AssetGuid subject",
+      "run asset.list or asset.inspect to obtain a current subject locator",
+      { requestId: operation.requestId, subject: operation.subject }
+    )
+  );
+}
+async function inspectAsset(gameRoot, snapshot, operation) {
+  const selected = subjectFor(gameRoot, snapshot, operation);
+  if (!selected.ok) return selected;
+  const subject = selected.value;
+  if (operation.sourceKey !== void 0) {
+    if (!isValidPackSourceKey(operation.sourceKey)) {
+      return err(
+        makeError(
+          "pack-source-key-invalid",
+          "a stable lower-case sourceKey",
+          "repair sourceKey before inspecting the output identity",
+          { requestId: operation.requestId, sourceKey: operation.sourceKey },
+          operation.sourceKey
+        )
+      );
+    }
+    if (subject.format === "direct") {
+      const asset = subject.assets.find((candidate) => candidate.sourceKey === operation.sourceKey);
+      if (asset === void 0) {
+        return err(
+          makeError(
+            "pack-output-not-materialized",
+            "sourceKey to exist in the direct Pack",
+            "inspect the current source and choose an existing sourceKey",
+            {
+              requestId: operation.requestId,
+              sourceKey: operation.sourceKey,
+              packageId: PackageId.format(subject.packageId)
+            }
+          )
+        );
+      }
+      const materialized = snapshot.materialized.find(
+        (candidate) => candidate.packageId === packageKey(subject.packageId) && candidate.sourceKey === operation.sourceKey
+      );
+      return ok({
+        ...sourceResult(subject, operation),
+        sourceKey: asset.sourceKey,
+        guid: asset.guid,
+        kind: asset.kind,
+        status: materialized === void 0 ? "identity" : materialized.ready ? "ready" : "present"
+      });
+    }
+    try {
+      const guid = AssetGuid.format(AssetGuid.derive(subject.packageId, operation.sourceKey));
+      const materialized = [...snapshot.materialized].find(
+        (candidate) => candidate.packageId === packageKey(subject.packageId) && candidate.sourceKey === operation.sourceKey
+      );
+      return ok({
+        ...sourceResult(subject, operation),
+        sourceKey: operation.sourceKey,
+        guid,
+        ...materialized === void 0 ? { status: "identity" } : {
+          status: materialized.ready ? "ready" : "present",
+          kind: materialized.kind
+        }
+      });
+    } catch (cause) {
+      return err(
+        makeError(
+          "pack-source-key-invalid",
+          "a valid lower-case sourceKey",
+          "repair sourceKey before inspecting the output identity",
+          { requestId: operation.requestId, sourceKey: operation.sourceKey, cause: String(cause) },
+          operation.sourceKey
+        )
+      );
+    }
+  }
+  if (subject.format === "instance") {
+    const resolved = await resolveInstance(snapshot, subject);
+    if (!resolved.ok) return resolved;
+    return ok({
+      ...sourceResult(subject, operation),
+      parameters: resolved.value.parameters.map((parameter) => ({
+        name: parameter.name,
+        type: parameter.type,
+        default: jsonValue2(parameter.default),
+        ...parameter.minimum === void 0 ? {} : { minimum: parameter.minimum },
+        ...parameter.maximum === void 0 ? {} : { maximum: parameter.maximum },
+        ...parameter.values === void 0 ? {} : { values: parameter.values },
+        ...parameter.kind === void 0 ? {} : { kind: parameter.kind }
+      })),
+      effectiveValues: jsonValue2(resolved.value.values),
+      parentChain: resolved.value.parentChain
+    });
+  }
+  return ok(sourceResult(subject, operation));
+}
+function listAssets(snapshot, operation) {
+  const assets = snapshotAssets(snapshot).map((asset) => ({
+    packageId: asset.packageId,
+    sourceKey: asset.sourceKey,
+    guid: asset.guid,
+    kind: asset.kind,
+    ...asset.name === void 0 ? {} : { name: asset.name },
+    ...asset.sourcePath === void 0 ? {} : { sourcePath: asset.sourcePath },
+    status: !("ready" in asset) ? "identity" : asset.ready ? "ready" : "present"
+  })).sort(
+    (left, right) => `${left.packageId}/${left.sourceKey}`.localeCompare(`${right.packageId}/${right.sourceKey}`)
+  );
+  const sources = [...snapshot.subjects.values()].map((subject) => {
+    if (subject.format === "source") {
+      const parameters = serializedParameters(subject.definition);
+      return {
+        packageId: PackageId.format(subject.packageId),
+        sourcePath: subject.relativePath,
+        format: "pack.ts",
+        ...parameters === void 0 ? {} : { parameters }
+      };
+    }
+    if (subject.format === "instance") {
+      return {
+        packageId: PackageId.format(subject.packageId),
+        sourcePath: subject.relativePath,
+        format: "instance",
+        parentPackageId: PackageId.format(subject.parent),
+        values: jsonValue2(subject.values)
+      };
+    }
+    return {
+      packageId: PackageId.format(subject.packageId),
+      sourcePath: subject.relativePath,
+      format: "direct"
+    };
+  }).sort(
+    (left, right) => `${left.packageId}/${left.sourcePath}`.localeCompare(
+      `${right.packageId}/${right.sourcePath}`
+    )
+  );
+  return {
+    operation: operation.operation,
+    requestId: operation.requestId,
+    assets,
+    sources,
+    snapshot: { sourceCount: snapshot.subjects.size, assetCount: assets.length }
+  };
+}
+function snapshotAssets(snapshot) {
+  const assets = /* @__PURE__ */ new Map();
+  for (const asset of snapshot.directAssets) {
+    assets.set(`${asset.packageId}/${asset.sourceKey}`, asset);
+  }
+  for (const asset of snapshot.materialized) {
+    assets.set(`${asset.packageId}/${asset.sourceKey}`, asset);
+  }
+  return [...assets.values()];
+}
+function assetForPair(snapshot, packageId2, sourceKey2) {
+  const key = `${packageKey(packageId2)}/${sourceKey2}`;
+  return snapshotAssets(snapshot).find((asset) => `${asset.packageId}/${asset.sourceKey}` === key);
+}
+async function resolveAsset(gameRoot, snapshot, operation) {
+  if (operation.require !== void 0 && operation.require !== "identity" && operation.require !== "present" && operation.require !== "ready") {
+    return err(
+      makeError(
+        "pack-parameter-invalid",
+        "require to be 'identity', 'present', or 'ready'",
+        "choose one of the three Pack identity proof levels",
+        { requestId: operation.requestId, require: operation.require }
+      )
+    );
+  }
+  let packageId2;
+  let sourceKey2 = operation.sourceKey;
+  let resolvedOutputGuid;
+  if (operation.packageId !== void 0) {
+    const parsed = PackageId.parse(operation.packageId);
+    if (!parsed.ok) {
+      return err(
+        makeError(
+          "pack-package-id-invalid",
+          "a UUID packageId",
+          "repair packageId before resolving a sourceKey",
+          { requestId: operation.requestId },
+          operation.packageId
+        )
+      );
+    }
+    packageId2 = parsed.value;
+  }
+  if (operation.subject !== void 0 && isValidAssetGuidString(operation.subject)) {
+    const found = [...snapshot.directAssets, ...snapshot.materialized].find(
+      (asset2) => asset2.guid === operation.subject?.toLowerCase()
+    );
+    if (found !== void 0) {
+      const parsed = PackageId.parse(found.packageId);
+      if (parsed.ok) {
+        if (packageId2 !== void 0 && packageKey(packageId2) !== packageKey(parsed.value)) {
+          return err(
+            makeError(
+              "pack-parameter-invalid",
+              "packageId and AssetGuid to identify the same Pack subject",
+              "remove the conflicting locator or resolve the pair from one source",
+              {
+                requestId: operation.requestId,
+                packageId: PackageId.format(packageId2),
+                observedPackageId: found.packageId,
+                guid: operation.subject
+              }
+            )
+          );
+        }
+        if (sourceKey2 !== void 0 && sourceKey2 !== found.sourceKey) {
+          return err(
+            makeError(
+              "pack-parameter-invalid",
+              "sourceKey and AssetGuid to identify the same Pack output",
+              "remove the conflicting locator or use the sourceKey returned by asset.list",
+              {
+                requestId: operation.requestId,
+                sourceKey: sourceKey2,
+                observedSourceKey: found.sourceKey,
+                guid: operation.subject
+              }
+            )
+          );
+        }
+        packageId2 = parsed.value;
+        sourceKey2 ??= found.sourceKey;
+        resolvedOutputGuid = found.guid;
+      }
+    }
+  }
+  if (packageId2 === void 0 && operation.subject !== void 0 && isValidAssetGuidString(operation.subject)) {
+    const parsed = PackageId.parse(operation.subject);
+    if (parsed.ok) packageId2 = parsed.value;
+  }
+  const sourceLocatorCandidate = operation.sourcePath ?? (operation.subject !== void 0 && !isValidAssetGuidString(operation.subject) ? operation.subject : void 0);
+  let sourceLocator;
+  if (sourceLocatorCandidate !== void 0) {
+    const confined = confinedPath(gameRoot, sourceLocatorCandidate, operation);
+    if (!confined.ok) return confined;
+    sourceLocator = confined.value.relative;
+  }
+  if (sourceLocator !== void 0) {
+    const source = [...snapshot.subjects.values()].find(
+      (candidate) => candidate.relativePath === sourceLocator
+    );
+    if (source === void 0) {
+      return err(
+        pathError(
+          "pack-source-not-found",
+          operation,
+          "sourcePath to identify a current Pack subject",
+          "inspect the current Source Index and choose an existing source path",
+          { sourcePath: sourceLocator },
+          sourceLocator
+        )
+      );
+    }
+    if (packageId2 !== void 0 && packageKey(packageId2) !== packageKey(source.packageId)) {
+      return err(
+        makeError(
+          "pack-parameter-invalid",
+          "sourcePath and packageId to identify the same Pack subject",
+          "remove the conflicting locator or use the packageId returned by asset.list",
+          {
+            requestId: operation.requestId,
+            sourcePath: sourceLocator,
+            packageId: PackageId.format(packageId2),
+            observedPackageId: PackageId.format(source.packageId)
+          }
+        )
+      );
+    }
+    packageId2 ??= source.packageId;
+  }
+  if (packageId2 === void 0 || sourceKey2 === void 0) {
+    return err(
+      makeError(
+        "pack-parameter-invalid",
+        "packageId and sourceKey (or a known output GUID)",
+        "pass packageId + sourceKey, a known AssetGuid, or a source path plus sourceKey",
+        { requestId: operation.requestId, packageId: operation.packageId, sourceKey: sourceKey2 }
+      )
+    );
+  }
+  if (!isValidPackSourceKey(sourceKey2)) {
+    return err(
+      makeError(
+        "pack-source-key-invalid",
+        "a stable lower-case sourceKey",
+        "repair sourceKey before deriving its AssetGuid",
+        { requestId: operation.requestId, sourceKey: sourceKey2 },
+        sourceKey2
+      )
+    );
+  }
+  let guid;
+  try {
+    guid = AssetGuid.derive(packageId2, sourceKey2);
+  } catch (cause) {
+    return err(
+      makeError(
+        "pack-source-key-invalid",
+        "a valid packageId and sourceKey pair",
+        "repair the identity pair before resolving",
+        {
+          requestId: operation.requestId,
+          cause: cause instanceof Error ? cause.message : String(cause)
+        }
+      )
+    );
+  }
+  const guidString = AssetGuid.format(guid);
+  if (resolvedOutputGuid !== void 0 && guidString.toLowerCase() !== resolvedOutputGuid) {
+    return err(
+      makeError(
+        "pack-guid-collision",
+        "the known output GUID to equal UUIDv5(packageId, sourceKey)",
+        "rebuild the current generation from the stable identity pair",
+        {
+          requestId: operation.requestId,
+          packageId: PackageId.format(packageId2),
+          sourceKey: sourceKey2,
+          expectedGuid: guidString,
+          observedGuid: resolvedOutputGuid
+        }
+      )
+    );
+  }
+  const asset = assetForPair(snapshot, packageId2, sourceKey2);
+  const materialized = snapshot.materialized.find(
+    (candidate) => candidate.packageId === packageKey(packageId2) && candidate.sourceKey === sourceKey2
+  );
+  const requirement = operation.require ?? "identity";
+  if (requirement === "present" && materialized === void 0) {
+    return err(
+      makeError(
+        "pack-output-not-materialized",
+        "the current build topology to contain this sourceKey",
+        "run rebuild/cold-cook and retry after the current generation publishes the output",
+        {
+          requestId: operation.requestId,
+          packageId: PackageId.format(packageId2),
+          sourceKey: sourceKey2,
+          guid: guidString
+        }
+      )
+    );
+  }
+  if (requirement === "ready" && (materialized === void 0 || !materialized.ready)) {
+    return err(
+      makeError(
+        "asset-not-ready",
+        "current Pack evidence and artifacts for this derived GUID",
+        "inspect producer evidence, then rebuild or cold-cook the same subject",
+        {
+          requestId: operation.requestId,
+          packageId: PackageId.format(packageId2),
+          sourceKey: sourceKey2,
+          guid: guidString
+        }
+      )
+    );
+  }
+  return ok({
+    operation: operation.operation,
+    requestId: operation.requestId,
+    packageId: PackageId.format(packageId2),
+    sourceKey: sourceKey2,
+    guid: guidString,
+    status: materialized === void 0 ? "identity" : materialized.ready ? "ready" : "present",
+    ...asset === void 0 ? {} : {
+      ...asset.sourcePath === void 0 ? {} : { sourcePath: asset.sourcePath },
+      kind: asset.kind
+    }
+  });
+}
+async function verify(snapshot, operation) {
+  for (const subject of snapshot.subjects.values()) {
+    if (subject.format === "instance") {
+      const resolved = await resolveInstance(snapshot, subject);
+      if (!resolved.ok) return err(resolved.error);
+    }
+    if (subject.format === "direct") {
+      for (const asset of subject.assets) {
+        const missing = asset.refs.find((ref) => !snapshot.knownGuids.has(ref.toLowerCase()));
+        if (missing !== void 0) {
+          return err(
+            makeError(
+              "pack-output-reference-missing",
+              "every direct Pack ref to resolve to a known AssetGuid",
+              "repair the payload ref or add the owning external asset before verifying",
+              {
+                requestId: operation.requestId,
+                packageId: PackageId.format(subject.packageId),
+                sourceKey: asset.sourceKey,
+                guid: missing
+              }
+            )
+          );
+        }
+      }
+    }
+  }
+  for (const asset of snapshotAssets(snapshot)) {
+    const missing = asset.refs?.find((ref) => !snapshot.knownGuids.has(ref.toLowerCase()));
+    if (missing !== void 0) {
+      return err(
+        makeError(
+          "pack-output-reference-missing",
+          "every materialized Pack ref to resolve to a known AssetGuid",
+          "repair the published output reference or publish its owning asset before verifying",
+          {
+            requestId: operation.requestId,
+            packageId: asset.packageId,
+            sourceKey: asset.sourceKey,
+            guid: missing
+          }
+        )
+      );
+    }
+  }
+  return ok({
+    operation: operation.operation,
+    requestId: operation.requestId,
+    snapshot: {
+      sourceCount: snapshot.subjects.size,
+      assetCount: snapshotAssets(snapshot).length
+    }
+  });
+}
+function packageIdFromOperation(snapshot, operation) {
+  const value = operation.packageId === void 0 ? ok(PackageId.random()) : PackageId.parse(operation.packageId);
+  if (!value.ok) {
+    return err(
+      makeError(
+        "pack-package-id-invalid",
+        "a UUID packageId",
+        "repair packageId or omit it so the gateway can mint one",
+        { requestId: operation.requestId },
+        operation.packageId
+      )
+    );
+  }
+  const normalized = packageKey(value.value);
+  const alreadyMaterialized = snapshot.materialized.some((asset) => asset.packageId === normalized);
+  return snapshot.subjects.has(normalized) || alreadyMaterialized ? err(
+    makeError(
+      "pack-package-id-collision",
+      "a packageId unused by the current Source Index",
+      "choose a new packageId or use clone without an explicit identity",
+      { requestId: operation.requestId, packageId: PackageId.format(value.value) }
+    )
+  ) : ok(value.value);
+}
+async function readConfined(options, operation, sourcePath) {
+  const path = confinedPath(options.gameRoot, sourcePath, operation);
+  if (!path.ok) return path;
+  try {
+    const source = await readFile(path.value.absolute, "utf8");
+    return ok({ ...path.value, source, revision: revisionOf(source) });
+  } catch (cause) {
+    const code = cause.code === "ENOENT" ? "pack-source-not-found" : "pack-source-write-failed";
+    return err(
+      pathError(
+        code,
+        operation,
+        "the requested Pack source to be readable",
+        "restore the source or choose a current locator",
+        {
+          sourcePath: path.value.relative,
+          cause: cause instanceof Error ? cause.message : String(cause)
+        },
+        path.value.relative
+      )
+    );
+  }
+}
+function revisionConflict(operation, path, actual) {
+  return makeError(
+    "pack-source-revision-conflict",
+    "expectedRevision to match the current source bytes",
+    "inspect the current source, reconcile the edit, and retry with a new requestId",
+    {
+      requestId: operation.requestId,
+      sourcePath: path,
+      expectedRevision: operation.expectedRevision,
+      actualRevision: actual
+    },
+    actual
+  );
+}
+function directJson(packageId2, assets) {
+  return { schemaVersion: "3.0.0", packageId: PackageId.format(packageId2), assets };
+}
+function parameterizedScaffold(packageId2, parameters) {
+  const parameterSource = parameters === void 0 ? "" : "\n  parameters: " + JSON.stringify(
+    parameters.map((parameter) => jsonValue2(parameter)),
+    null,
+    2
+  ).replaceAll("\n", "\n  ") + ",";
+  return "import { definePack, definePackageId } from '@forgeax/engine-pack/source';\nimport { ok } from '@forgeax/engine-types';\n\nconst packageId = definePackageId(" + JSON.stringify(PackageId.format(packageId2)) + ");\n\nexport default definePack({\n  schemaVersion: '2.0.0',\n  packageId," + parameterSource + "\n  build: () => ok({}),\n});\n";
+}
+function replacePackageIdLiteral(source, packageId2) {
+  const pattern = /(definePackageId\s*\(\s*)(['"])([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12})(\2\s*\))/;
+  if (!pattern.test(source)) return void 0;
+  return source.replace(pattern, `$1${JSON.stringify(packageId2)}$4`);
+}
+async function inspectAfterWrite(operation, path, source, packageId2, extra = {}) {
+  return ok({
+    operation: operation.operation,
+    requestId: operation.requestId,
+    sourcePath: path.relative,
+    targetPath: path.relative,
+    packageId: PackageId.format(packageId2),
+    revision: revisionOf(source),
+    ...extra
+  });
+}
+async function executeRaw(options, operation) {
+  if (operation.operation === "asset.list" || operation.operation === "asset.inspect") {
+    const snapshot2 = await createSnapshot(options, operation);
+    if (!snapshot2.ok) return snapshot2;
+    return operation.operation === "asset.list" ? ok(listAssets(snapshot2.value, operation)) : await inspectAsset(options.gameRoot, snapshot2.value, operation);
+  }
+  const snapshot = await createSnapshot(options, operation);
+  if (!snapshot.ok) return snapshot;
+  if (operation.operation === "asset.resolve")
+    return resolveAsset(options.gameRoot, snapshot.value, operation);
+  if (operation.operation === "asset.verify") return verify(snapshot.value, operation);
+  if (operation.operation === "asset-source.create") {
+    const path = confinedPath(
+      options.gameRoot,
+      operation.targetPath ?? operation.sourcePath,
+      operation
+    );
+    if (!path.ok) return path;
+    try {
+      await stat(path.value.absolute);
+      return err(
+        pathError(
+          "pack-source-revision-conflict",
+          operation,
+          "an unused target source path",
+          "inspect the existing source or choose another target path",
+          { targetPath: path.value.relative },
+          path.value.relative
+        )
+      );
+    } catch (cause) {
+      if (cause.code !== "ENOENT") {
+        return err(
+          pathError(
+            "pack-source-write-failed",
+            operation,
+            "the target path to be available for atomic creation",
+            "repair the filesystem and retry",
+            { targetPath: path.value.relative, cause: String(cause) }
+          )
+        );
+      }
+    }
+    const identity = packageIdFromOperation(snapshot.value, operation);
+    if (!identity.ok) return identity;
+    const format = operation.format ?? (path.value.relative.endsWith(".pack.json") ? "pack.json" : "pack.ts");
+    if (format === "pack.json" && !path.value.relative.endsWith(".pack.json") || format === "pack.ts" && !path.value.relative.endsWith(".pack.ts")) {
+      return err(
+        makeError(
+          "pack-source-path-invalid",
+          "format and target extension to agree",
+          "use a .pack.ts target for source creation or a .pack.json target for direct data",
+          { requestId: operation.requestId, format, targetPath: path.value.relative }
+        )
+      );
+    }
+    let source;
+    let extra = { format };
+    if (format === "pack.json") {
+      if (operation.parameters !== void 0 || operation.parent !== void 0 || operation.parentPackageId !== void 0 || operation.values !== void 0) {
+        return err(
+          makeError(
+            "pack-parameter-invalid",
+            "direct create to contain assets only",
+            "use pack.ts for a parameterized source or create-instance for parent+values",
+            { requestId: operation.requestId }
+          )
+        );
+      }
+      const assets = operation.initialAssets ?? {};
+      const parsed = parseParameterizedPackJson(directJson(identity.value, assets));
+      if (!parsed.ok) return err(parsed.error);
+      if (parsed.value.format !== "direct") {
+        return err(
+          makeError(
+            "pack-parameter-invalid",
+            "direct create to produce a direct v3 Pack document",
+            "use create-instance for parent + values instead of direct assets",
+            { requestId: operation.requestId }
+          )
+        );
+      }
+      source = `${JSON.stringify(directJson(identity.value, parsed.value.assets), null, 2)}
+`;
+    } else {
+      if (operation.initialAssets !== void 0 && Object.keys(operation.initialAssets).length > 0) {
+        return err(
+          makeError(
+            "pack-parameter-invalid",
+            "a pack.ts source to define its outputs in build()",
+            "use pack.json for direct assets or omit initialAssets when creating a pack.ts source",
+            { requestId: operation.requestId }
+          )
+        );
+      }
+      if (operation.parent !== void 0 || operation.parentPackageId !== void 0 || operation.values !== void 0) {
+        return err(
+          makeError(
+            "pack-parameter-invalid",
+            "a new pack.ts source without instance-only parent/value fields",
+            "use asset-source.create-instance for parent + values",
+            { requestId: operation.requestId }
+          )
+        );
+      }
+      let parameters;
+      if (operation.parameters !== void 0) {
+        const validated = validatePackDefinition({
+          schemaVersion: "2.0.0",
+          packageId: identity.value,
+          parameters: operation.parameters,
+          build: () => ok({})
+        });
+        if (!validated.ok) return err(validated.error);
+        if (!("parameters" in validated.value)) {
+          return err(
+            makeError(
+              "pack-parameter-invalid",
+              "parameters to be non-empty when supplied",
+              "omit parameters for a zero-parameter Pack",
+              { requestId: operation.requestId }
+            )
+          );
+        }
+        parameters = validated.value.parameters;
+      }
+      source = parameterizedScaffold(identity.value, parameters);
+      const serialized = parameters === void 0 ? void 0 : serializedParameters({
+        schemaVersion: "2.0.0",
+        packageId: identity.value,
+        parameters,
+        build: () => ok({})
+      });
+      extra = {
+        format,
+        ...serialized === void 0 ? {} : { parameters: serialized }
+      };
+    }
+    try {
+      await atomicWrite(path.value.absolute, source);
+    } catch (cause) {
+      return err(
+        pathError(
+          "pack-source-write-failed",
+          operation,
+          "the new Pack source to be written atomically",
+          "repair filesystem permissions or disk capacity, then retry with a new requestId",
+          {
+            targetPath: path.value.relative,
+            cause: cause instanceof Error ? cause.message : String(cause)
+          }
+        )
+      );
+    }
+    return inspectAfterWrite(operation, path.value, source, identity.value, extra);
+  }
+  if (operation.operation === "asset-source.clone") {
+    const read = await readConfined(options, operation, operation.sourcePath);
+    if (!read.ok) return read;
+    if (operation.expectedRevision !== void 0 && operation.expectedRevision !== read.value.revision) {
+      return err(revisionConflict(operation, read.value.relative, read.value.revision));
+    }
+    const target = confinedPath(options.gameRoot, operation.targetPath, operation);
+    if (!target.ok) return target;
+    const sourceIsTypeScript = read.value.relative.endsWith(".pack.ts");
+    const targetIsTypeScript = target.value.relative.endsWith(".pack.ts");
+    if (sourceIsTypeScript !== targetIsTypeScript) {
+      return err(
+        makeError(
+          "pack-source-path-invalid",
+          "clone source and target to use the same .pack.ts or .pack.json format",
+          "preserve the source extension when cloning a Pack subject",
+          {
+            requestId: operation.requestId,
+            sourcePath: read.value.relative,
+            targetPath: target.value.relative
+          }
+        )
+      );
+    }
+    try {
+      await stat(target.value.absolute);
+      return err(
+        pathError(
+          "pack-source-revision-conflict",
+          operation,
+          "an unused clone target path",
+          "inspect the target or choose another path",
+          { targetPath: target.value.relative },
+          target.value.relative
+        )
+      );
+    } catch (cause) {
+      if (cause.code !== "ENOENT") {
+        return err(
+          pathError(
+            "pack-source-write-failed",
+            operation,
+            "the clone target to be writable",
+            "repair filesystem permissions and retry",
+            { targetPath: target.value.relative, cause: String(cause) }
+          )
+        );
+      }
+    }
+    const identity = packageIdFromOperation(snapshot.value, operation);
+    if (!identity.ok) return identity;
+    let source = read.value.source;
+    if (read.value.relative.endsWith(".pack.json")) {
+      let parsedValue;
+      try {
+        parsedValue = JSON.parse(source);
+      } catch {
+        return err(
+          makeError(
+            "pack-parameter-invalid",
+            "a valid v3 pack.json document",
+            "repair the source before cloning it",
+            { requestId: operation.requestId, sourcePath: read.value.relative }
+          )
+        );
+      }
+      const parsed = parseParameterizedPackJson(parsedValue);
+      if (!parsed.ok) return err(parsed.error);
+      source = `${JSON.stringify(
+        parsed.value.format === "direct" ? directJson(identity.value, parsed.value.assets) : {
+          schemaVersion: "3.0.0",
+          packageId: PackageId.format(identity.value),
+          parent: PackageId.format(parsed.value.parent),
+          values: parsed.value.values
+        },
+        null,
+        2
+      )}
+`;
+    } else {
+      const replaced = replacePackageIdLiteral(source, PackageId.format(identity.value));
+      if (replaced === void 0) {
+        return err(
+          makeError(
+            "pack-source-mutation-unsupported",
+            "a constrained definePackageId(UUID) literal in the source",
+            "clone a generated Pack source or create a new Pack; arbitrary TypeScript AST rewriting is unsupported",
+            { requestId: operation.requestId, sourcePath: read.value.relative }
+          )
+        );
+      }
+      source = replaced;
+    }
+    try {
+      await atomicWrite(target.value.absolute, source);
+    } catch (cause) {
+      return err(
+        pathError(
+          "pack-source-write-failed",
+          operation,
+          "the cloned Pack source to be written atomically",
+          "repair filesystem permissions or disk capacity, then retry",
+          {
+            targetPath: target.value.relative,
+            cause: cause instanceof Error ? cause.message : String(cause)
+          }
+        )
+      );
+    }
+    return inspectAfterWrite(operation, target.value, source, identity.value, {
+      format: target.value.relative.endsWith(".pack.json") ? "pack.json" : "pack.ts"
+    });
+  }
+  if (operation.operation === "asset-source.create-instance") {
+    const target = confinedPath(
+      options.gameRoot,
+      operation.targetPath ?? operation.sourcePath,
+      operation
+    );
+    if (!target.ok) return target;
+    const parentText = operation.parentPackageId ?? operation.parent;
+    if (parentText === void 0) {
+      return err(
+        makeError(
+          "pack-parent-not-found",
+          "a parent packageId for the new instance",
+          "pass parentPackageId or parent and point it at a parameterized source",
+          { requestId: operation.requestId }
+        )
+      );
+    }
+    const parentId = PackageId.parse(parentText);
+    if (!parentId.ok) {
+      return err(
+        makeError(
+          "pack-package-id-invalid",
+          "a UUID parent packageId",
+          "repair the parent package identity",
+          { requestId: operation.requestId },
+          parentText
+        )
+      );
+    }
+    const parent = snapshot.value.subjects.get(packageKey(parentId.value));
+    if (parent === void 0) {
+      return err(
+        makeError(
+          "pack-parent-not-found",
+          "the parent packageId to exist in the current Source Index",
+          "inspect the Source Index and choose a parameterized parent",
+          { requestId: operation.requestId, parent: parentText }
+        )
+      );
+    }
+    if (parent.format === "source" && !("parameters" in parent.definition)) {
+      return err(
+        makeError(
+          "pack-parent-not-parameterized",
+          "a non-empty parameterized Pack source as the parent",
+          "use asset-source.clone for a zero-parameter Pack",
+          { requestId: operation.requestId, parent: parentText }
+        )
+      );
+    }
+    if (parent.format === "direct") {
+      return err(
+        makeError(
+          "pack-parent-not-parameterized",
+          "a parameterized Pack source or instance as the parent",
+          "direct Packs cannot be instance parents",
+          { requestId: operation.requestId, parent: parentText }
+        )
+      );
+    }
+    try {
+      await stat(target.value.absolute);
+      return err(
+        pathError(
+          "pack-source-revision-conflict",
+          operation,
+          "an unused instance target path",
+          "inspect the existing instance or choose another path",
+          { targetPath: target.value.relative },
+          target.value.relative
+        )
+      );
+    } catch (cause) {
+      if (cause.code !== "ENOENT") {
+        return err(
+          pathError(
+            "pack-source-write-failed",
+            operation,
+            "the instance target to be writable",
+            "repair filesystem permissions and retry",
+            { targetPath: target.value.relative, cause: String(cause) }
+          )
+        );
+      }
+    }
+    const identity = packageIdFromOperation(snapshot.value, operation);
+    if (!identity.ok) return identity;
+    const values = operation.values ?? {};
+    const serializedValues = jsonValue2(values);
+    const candidate = {
+      format: "instance",
+      packageId: identity.value,
+      parent: parentId.value,
+      values,
+      sourcePath: target.value.absolute,
+      relativePath: target.value.relative
+    };
+    const withCandidate = {
+      ...snapshot.value,
+      subjects: new Map([...snapshot.value.subjects, [packageKey(identity.value), candidate]])
+    };
+    const resolved = await resolveInstance(withCandidate, candidate);
+    if (!resolved.ok) return err(resolved.error);
+    const source = `${JSON.stringify(
+      {
+        schemaVersion: "3.0.0",
+        packageId: PackageId.format(identity.value),
+        parent: PackageId.format(parentId.value),
+        values: serializedValues
+      },
+      null,
+      2
+    )}
+`;
+    try {
+      await atomicWrite(target.value.absolute, source);
+    } catch (cause) {
+      return err(
+        pathError(
+          "pack-source-write-failed",
+          operation,
+          "the new instance to be written atomically",
+          "repair filesystem permissions or disk capacity, then retry",
+          {
+            targetPath: target.value.relative,
+            cause: cause instanceof Error ? cause.message : String(cause)
+          }
+        )
+      );
+    }
+    return inspectAfterWrite(operation, target.value, source, identity.value, {
+      format: "instance",
+      parentPackageId: PackageId.format(parentId.value),
+      values: serializedValues,
+      effectiveValues: jsonValue2(resolved.value.values),
+      parentChain: resolved.value.parentChain
+    });
+  }
+  if (operation.operation === "asset-source.apply-values") {
+    const read = await readConfined(options, operation, operation.sourcePath);
+    if (!read.ok) return read;
+    if (operation.expectedRevision === void 0 || operation.expectedRevision !== read.value.revision) {
+      return err(revisionConflict(operation, read.value.relative, read.value.revision));
+    }
+    let json;
+    try {
+      json = JSON.parse(read.value.source);
+    } catch {
+      return err(
+        makeError(
+          "pack-parameter-invalid",
+          "a valid v3 instance JSON document",
+          "repair the source before applying values",
+          { requestId: operation.requestId, sourcePath: read.value.relative }
+        )
+      );
+    }
+    const parsed = parseParameterizedPackJson(json);
+    if (!parsed.ok) return err(parsed.error);
+    if (parsed.value.format !== "instance") {
+      return err(
+        makeError(
+          "pack-parameter-invalid",
+          "an instance pack.json subject",
+          "apply-values only edits parent+values instances",
+          { requestId: operation.requestId, sourcePath: read.value.relative }
+        )
+      );
+    }
+    const values = operation.values ?? {};
+    const serializedValues = jsonValue2(values);
+    const candidate = {
+      format: "instance",
+      packageId: parsed.value.packageId,
+      parent: parsed.value.parent,
+      values,
+      sourcePath: read.value.absolute,
+      relativePath: read.value.relative
+    };
+    const withCandidate = {
+      ...snapshot.value,
+      subjects: new Map([...snapshot.value.subjects, [packageKey(candidate.packageId), candidate]])
+    };
+    const resolved = await resolveInstance(withCandidate, candidate);
+    if (!resolved.ok) return err(resolved.error);
+    const source = `${JSON.stringify(
+      {
+        schemaVersion: "3.0.0",
+        packageId: PackageId.format(parsed.value.packageId),
+        parent: PackageId.format(parsed.value.parent),
+        values: serializedValues
+      },
+      null,
+      2
+    )}
+`;
+    try {
+      await atomicWrite(read.value.absolute, source);
+    } catch (cause) {
+      return err(
+        pathError(
+          "pack-source-write-failed",
+          operation,
+          "the updated instance to be written atomically",
+          "repair filesystem permissions or disk capacity, then retry with a new requestId",
+          {
+            sourcePath: read.value.relative,
+            cause: cause instanceof Error ? cause.message : String(cause)
+          }
+        )
+      );
+    }
+    return inspectAfterWrite(operation, read.value, source, parsed.value.packageId, {
+      format: "instance",
+      parentPackageId: PackageId.format(parsed.value.parent),
+      values: serializedValues,
+      effectiveValues: jsonValue2(resolved.value.values),
+      parentChain: resolved.value.parentChain
+    });
+  }
+  if (operation.operation === "asset-source.rebuild" || operation.operation === "asset-source.cold-cook") {
+    const read = await readConfined(options, operation, operation.sourcePath);
+    if (!read.ok) return read;
+    if (operation.expectedRevision === void 0 || operation.expectedRevision !== read.value.revision) {
+      return err(revisionConflict(operation, read.value.relative, read.value.revision));
+    }
+    const rebuilt = await options.rebuild?.(
+      read.value.relative,
+      operation.operation === "asset-source.rebuild" ? "rebuild" : "cold-cook"
+    );
+    if (rebuilt === void 0) {
+      return err(
+        makeError(
+          "pack-source-mutation-unsupported",
+          "a build-owner callback for rebuild or cold-cook",
+          "connect the gateway to the project build owner before requesting a mutation",
+          { requestId: operation.requestId, sourcePath: read.value.relative }
+        )
+      );
+    }
+    if (!rebuilt.ok) return err(rebuilt.error);
+    const refreshed = await readConfined(options, operation, operation.sourcePath);
+    if (!refreshed.ok) return refreshed;
+    const refreshedSnapshot = await createSnapshot(options, operation);
+    if (!refreshedSnapshot.ok) return refreshedSnapshot;
+    const selected = subjectFor(options.gameRoot, refreshedSnapshot.value, operation);
+    if (!selected.ok) return selected;
+    return inspectAfterWrite(
+      operation,
+      refreshed.value,
+      refreshed.value.source,
+      selected.value.packageId,
+      {
+        format: refreshed.value.relative.endsWith(".pack.json") ? "pack.json" : "pack.ts"
+      }
+    );
+  }
+  return err(
+    makeError(
+      "pack-parameter-invalid",
+      "a supported parameterized Pack operation",
+      "use one of PARAMETERIZED_PACK_OPERATION_IDS",
+      { requestId: operation.requestId, operation: operation.operation }
+    )
+  );
+}
+function createFileSystemParameterizedPackAuthoringPort(options) {
+  return { execute: (operation) => executeRaw(options, operation) };
+}
+function createFileSystemParameterizedPackAuthoringGateway(options) {
+  return createParameterizedPackAuthoringGateway(
+    createFileSystemParameterizedPackAuthoringPort(options)
+  );
+}
 function parsePackV2(value) {
   if (!validatePackV2(value)) {
     return err({
@@ -10107,8 +12620,8 @@ function stable(value) {
   if (value instanceof Uint8Array) return `bytes:${Buffer.from(value).toString("base64")}`;
   if (Array.isArray(value)) return `[${value.map(stable).join(",")}]`;
   if (value !== null && typeof value === "object") {
-    const record = value;
-    return `{${Object.keys(record).sort().map((key) => `${JSON.stringify(key)}:${stable(record[key])}`).join(",")}}`;
+    const record2 = value;
+    return `{${Object.keys(record2).sort().map((key) => `${JSON.stringify(key)}:${stable(record2[key])}`).join(",")}}`;
   }
   return JSON.stringify(value) ?? "null";
 }
@@ -10212,6 +12725,6 @@ function createRuntimePackPublication(input) {
   };
 }
 
-export { MESH_BIN_DIGEST_BYTES, MESH_BIN_HEADER_V4_BYTES, MESH_BIN_PROJECTION_VERSION, MESH_BIN_VERSION, SCRIPTABLE_PACK_ASSET_KINDS, SCRIPTABLE_PACK_CAPABILITY_MANIFEST, STANDARD_SCRIPTABLE_PACK_SCAN_OPTIONS, buildCatalogProjection, buildOfflineAssetEvidence, calculateCatalogDelta, calculateTopologyDiff, catalogProjectionFor, catalogSourcePathFor, collectMaterialCookRefs, createMaterialArtifactDigest, createRuntimePackPublication, currentProjectionFor, decodeMeshBinHeader, diffTopology, finalizePackageProduct, finalizePackageTransportSource, findReservedAssetKindConflict, isScriptablePackAssetKind, loadAssetConfig, metaPathForGuid, packageTransportRevision, packageVerification, parsePackV2, projectCookedMaterialRecord, projectCookedPackageEntry, projectExternalCatalogEntries, projectPackageCatalog, projectRuntimeCatalogRow, projectScriptablePackMeta, projectScriptablePackSceneComponents, resolveAssetSource, scanInventory, serializeCookedMaterialRecord, serializeMaterialCookReceipt, upgradeLegacyAuthoredPack, validateArtifactPath, validateCookedMaterialRecord, validateMaterialCookReceipt, validateMeta, validatePack, validatePackV2, validateProducerContract, validateProducerOutputs, validateScriptablePackDefinition, writeMeshBinHeader };
+export { AssetGuid, MESH_BIN_DIGEST_BYTES, MESH_BIN_HEADER_V4_BYTES, MESH_BIN_PROJECTION_VERSION, MESH_BIN_VERSION, PACK_PARAMETER_TYPES, PACK_SOURCE_KEY_RE, PARAMETERIZED_PACK_OPERATION_DESCRIPTORS, PARAMETERIZED_PACK_OPERATION_IDS, PackageId, SCRIPTABLE_PACK_ASSET_KINDS, STANDARD_SCRIPTABLE_PACK_SCAN_OPTIONS, buildCatalogProjection, buildOfflineAssetEvidence, calculateCatalogDelta, calculateTopologyDiff, catalogProjectionFor, catalogSourcePathFor, collectMaterialCookRefs, createFileSystemParameterizedPackAuthoringGateway, createFileSystemParameterizedPackAuthoringPort, createMaterialArtifactDigest, createParameterizedPackAuthoringGateway, createRuntimePackPublication, currentProjectionFor, decodeMeshBinHeader, definePack, definePackageId, diffTopology, finalizePackageProduct, finalizePackageTransportSource, findReservedAssetKindConflict, inventoryDigest, isParameterizedPack, isScriptablePackAssetKind, isValidAssetGuidString, isValidPackSourceKey, metaPathForGuid, packageTransportRevision, packageVerification, parsePackAuthoringJson, parsePackJson, parsePackV2, parseParameterizedPackJson, projectAssetRefs, projectCookedMaterialRecord, projectCookedPackageEntry, projectDirectPackJson, projectExternalCatalogEntries, projectPackageCatalog, projectParameterizedPackMeta, projectRuntimeCatalogRow, projectSceneEntityRefs, projectScriptablePackSceneComponents, resolveAssetSource, resolvePackInheritance, resolvePackParameterInheritance, resolvePackParameterValues, scanInventory, serializeCookedMaterialRecord, serializeMaterialCookReceipt, syncAuthorInventory, validateArtifactPath, validateAuthorInventory, validateCookedMaterialRecord, validateMaterialCookReceipt, validateMeta, validatePack, validatePackDefinition, validatePackV2, validateProducerContract, validateProducerOutputs, writeMeshBinHeader };
 //# sourceMappingURL=build.mjs.map
 //# sourceMappingURL=build.mjs.map