@forgeax/engine-pack 0.1.21 → 0.1.24

package/dist/index.mjs

@@ -1,6 +1,7 @@
-import { MATERIAL_TEXTURE_SLOTS, ok, projectCookProductEvidence, projectAssetEvidence, err, validateSourceOverrideMap } from '@forgeax/engine-types';
+import { deriveStandardLayerPlan, MATERIAL_TEXTURE_SLOTS, ok, projectCookProductEvidence, projectAssetEvidence, err, validateSourceOverrideMap } from '@forgeax/engine-types';
 import { sha256 } from '@noble/hashes/sha2.js';
 import { bytesToHex } from '@noble/hashes/utils.js';
+import { sha1 } from '@noble/hashes/legacy.js';
 import { uuidv7obj } from 'uuidv7';
 
 var __create = Object.create;
@@ -4708,8 +4709,8 @@ var require_multipleOf = __commonJS({
         const { gen, data, schemaCode, it } = cxt;
         const prec = it.opts.multipleOfPrecision;
         const res = gen.let("res");
-        const invalid4 = 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}, ${invalid4}))`);
+        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}))`);
       }
     };
     exports.default = def;
@@ -6814,6 +6815,24 @@ var require_dist = __commonJS({
     exports.default = formatsPlugin;
   }
 });
+var STANDARD_ROOT_MODULES = /* @__PURE__ */ new Set([
+  "forgeax::default-standard-pbr",
+  "forgeax::pbr-skin",
+  "forgeax_material::standard",
+  "forgeax_material::pbr-skin"
+]);
+function isStandardRootModule(module) {
+  return STANDARD_ROOT_MODULES.has(module);
+}
+function isStandardMaterialRecord(record) {
+  return record.resolved.passes.some((pass) => isStandardRootModule(pass.program.module));
+}
+function materialLayerPlanIdentity(record) {
+  if (!isStandardMaterialRecord(record)) {
+    return void 0;
+  }
+  return deriveStandardLayerPlan(record.resolved.parameters, record.resolved.passes).identity;
+}
 function unique(values) {
   return [...new Set(values)].sort();
 }
@@ -6896,14 +6915,14 @@ function serializeCookedMaterialRecord(record) {
 function serializeMaterialCookReceipt(receipt) {
   return JSON.stringify(jsonValue({ ...receipt, sourceClosure: unique(receipt.sourceClosure) }));
 }
-function invalid(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"
     }
   });
@@ -6964,6 +6983,12 @@ function validateMaterialCookReceipt(value, expected = {}) {
   if (derivedInterface.layoutIdentity !== identity.layoutIdentity) {
     return invalid("receipt.derivedInterface.layoutIdentity", derivedInterface.layoutIdentity);
   }
+  if (derivedInterface.layerPlanIdentity !== void 0 && (typeof derivedInterface.layerPlanIdentity !== "string" || derivedInterface.layerPlanIdentity.length === 0)) {
+    return invalid(
+      "receipt.derivedInterface.layerPlanIdentity",
+      derivedInterface.layerPlanIdentity
+    );
+  }
   for (const field of ["sourceClosure", "profile", "compilerVersion"]) {
     const fieldValue = candidate[field];
     if (field === "sourceClosure" && !Array.isArray(fieldValue) || field !== "sourceClosure" && typeof fieldValue !== "string") {
@@ -6989,7 +7014,10 @@ function validateMaterialCookReceipt(value, expected = {}) {
     profile: candidate.profile,
     compilerVersion: candidate.compilerVersion,
     identity,
-    derivedInterface: { layoutIdentity: derivedInterface.layoutIdentity }
+    derivedInterface: {
+      layoutIdentity: derivedInterface.layoutIdentity,
+      ...derivedInterface.layerPlanIdentity === void 0 ? {} : { layerPlanIdentity: derivedInterface.layerPlanIdentity }
+    }
   });
 }
 function validateCookedMaterialRecord(value) {
@@ -7032,6 +7060,26 @@ function validateCookedMaterialRecord(value) {
     artifactDigest: artifact.digest
   });
   if (!receiptResult.ok) return receiptResult;
+  const resolved = candidate.resolved;
+  if (!Array.isArray(resolved.passes)) return invalid("resolved.passes", resolved.passes);
+  if (!Array.isArray(resolved.parameters))
+    return invalid("resolved.parameters", resolved.parameters);
+  if (resolved.values === null || typeof resolved.values !== "object" || Array.isArray(resolved.values))
+    return invalid("resolved.values", resolved.values);
+  let expectedLayerPlanIdentity;
+  try {
+    expectedLayerPlanIdentity = materialLayerPlanIdentity({
+      resolved
+    });
+  } catch (error) {
+    return invalid("resolved.layerPlanIdentity", error instanceof Error ? error.message : error);
+  }
+  if (expectedLayerPlanIdentity !== void 0 && receiptResult.value.derivedInterface.layerPlanIdentity !== expectedLayerPlanIdentity) {
+    return invalid(
+      "receipt.derivedInterface.layerPlanIdentity",
+      receiptResult.value.derivedInterface.layerPlanIdentity
+    );
+  }
   if (candidate.artifactDigest !== void 0 && candidate.artifactDigest !== artifact.digest)
     return invalid("artifactDigest", candidate.artifactDigest);
   if (candidate.publicationGeneration !== void 0 && receiptResult.value.identity.cookGeneration !== candidate.publicationGeneration)
@@ -7095,12 +7143,146 @@ function packageVerification(input) {
   };
 }
 
+// src/errors.ts
+var PackError = class extends Error {
+  code;
+  expected;
+  hint;
+  detail;
+  constructor(args) {
+    super(`[PackError ${args.code}] expected: ${args.expected}; hint: ${args.hint}`);
+    this.name = "PackError";
+    this.code = args.code;
+    this.expected = args.expected;
+    this.hint = args.hint;
+    this.detail = args.detail;
+  }
+};
+
+// src/guid.ts
+function brand(bytes) {
+  return bytes;
+}
+var HEX_BYTE = Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, "0"));
+function bytesToDashForm(bytes) {
+  const h = HEX_BYTE;
+  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);
+}
+function dashFormToBytes(dashForm) {
+  const hex = dashForm.replace(/-/g, "");
+  const bytes = new Uint8Array(16);
+  for (let i = 0; i < 16; i++) {
+    bytes[i] = parseInt(hex.slice(i * 2, i * 2 + 2), 16);
+  }
+  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 digest = sha1(input);
+  const result = digest.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.
+   * Returns Ok(AssetGuid) on success or Err(PackError) with code 'pack-guid-malformed' on failure.
+   * Never throws for expected failures (requirements §4.2 / §14 / charter proposition 4).
+   */
+  parse(dashForm) {
+    if (!isValidAssetGuidString(dashForm)) {
+      return {
+        ok: false,
+        error: new PackError({
+          code: "pack-guid-malformed",
+          expected: "36-char RFC 4122 dash-form UUID",
+          hint: "use AssetGuid.random() or a UUIDv7 generator; all GUID fields must be 36-char RFC 4122 dash-form",
+          detail: {
+            raw: dashForm,
+            reason: "expected 36-char RFC 4122 dash-form UUID"
+          }
+        })
+      };
+    }
+    return { ok: true, value: brand(dashFormToBytes(dashForm)) };
+  },
+  /**
+   * Format an AssetGuid as a 36-char RFC 4122 lowercase dash-form string.
+   */
+  format(guid) {
+    return bytesToDashForm(guid);
+  },
+  /**
+   * Test byte-by-byte equality between two AssetGuids.
+   */
+  equals(a, b) {
+    for (let i = 0; i < 16; i++) {
+      if (a[i] !== b[i]) return false;
+    }
+    return true;
+  },
+  /**
+   * Mint a new time-ordered UUIDv7 as an AssetGuid.
+   * Works in both Node.js and browser environments.
+   */
+  random() {
+    return brand(randomUuidBytes());
+  },
+  /** Derive the stable UUIDv5 projection for one Pack subject and sourceKey. */
+  derive(namespace, sourceKey2) {
+    return derivedGuid(namespace, sourceKey2);
+  }
+};
+
 // 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 failure(code, sourceKey2, expected, actual) {
   return {
     ok: false,
     error: {
@@ -7108,7 +7290,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"
     }
   };
@@ -7187,41 +7369,1033 @@ function decodeMeshBinHeader(bytes, sourceKey2 = "<unknown mesh source>") {
     }
   };
 }
-function isRecord(value) {
+var PACK_PARAMETER_TYPES = [
+  "bool",
+  "u32",
+  "i32",
+  "f32",
+  "f64",
+  "string",
+  "enum",
+  "vec2",
+  "vec3",
+  "vec4",
+  "color",
+  "asset-guid"
+];
+function authoringError(code, expected, hint, detail = {}, actual) {
+  return {
+    code,
+    expected,
+    hint,
+    ...actual === void 0 ? {} : { actual },
+    detail
+  };
+}
+function failure2(error) {
+  return err(error);
+}
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function validateSceneComponents(value) {
+  if (value === void 0) return ok(void 0);
+  if (!Array.isArray(value)) {
+    return failure2(
+      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 failure2(
+        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 failure2(
+        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 failure2(
+          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 cloneValue(value) {
+  if (value instanceof Uint8Array) return value.slice();
+  if (Array.isArray(value)) return value.map((item) => cloneValue(item));
+  return value;
+}
+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
+  );
+}
+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) }
+  );
+}
+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;
+  }
+}
+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 (type === "string" && typeof value !== "string") {
+    return parameterFailure(propertyPath, "a string", value, "string parameter has the wrong type");
+  }
+  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;
+  }
+  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"
+      );
+    }
+    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 (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 failure2(error);
+  if (parameter.type === "asset-guid" && typeof value === "string") {
+    const parsed = AssetGuid.parse(value);
+    if (!parsed.ok) {
+      return failure2(
+        parameterFailure(
+          propertyPath,
+          "a valid AssetGuid UUID string",
+          value,
+          "asset GUID parser rejected the value"
+        )
+      );
+    }
+    return ok(parsed.value);
+  }
+  return ok(cloneValue(value));
+}
+function validateParameterDefinitions(parameters, propertyPath = "$.parameters") {
+  if (!Array.isArray(parameters) || parameters.length === 0) {
+    return failure2(
+      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 failure2(
+        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 failure2(
+        parameterFailure(
+          `${path}.name`,
+          "a unique identifier-like parameter name",
+          name,
+          "parameter name is invalid"
+        )
+      );
+    }
+    if (names.has(name))
+      return failure2(
+        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 failure2(
+        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 failure2(
+        parameterFailure(
+          `${path}.type`,
+          PACK_PARAMETER_TYPES.join(" | "),
+          type,
+          "parameter type is not supported"
+        )
+      );
+    }
+    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 failure2(
+          parameterFailure(
+            `${path}.values`,
+            "unique non-empty strings for enum",
+            typed.values,
+            "enum values are malformed"
+          )
+        );
+      }
+    } else if (typed.type === "enum") {
+      return failure2(
+        parameterFailure(
+          `${path}.values`,
+          "a non-empty enum choices array",
+          typed.values,
+          "enum has no choices"
+        )
+      );
+    }
+    if (typed.kind !== void 0 && (typed.type !== "asset-guid" || typeof typed.kind !== "string")) {
+      return failure2(
+        parameterFailure(
+          `${path}.kind`,
+          "a kind constraint only on asset-guid parameters",
+          typed.kind,
+          "kind is misplaced"
+        )
+      );
+    }
+    for (const field of ["minimum", "maximum"]) {
+      const bound = typed[field];
+      if (bound !== void 0 && (typeof bound !== "number" || !Number.isFinite(bound))) {
+        return failure2(
+          parameterFailure(
+            `${path}.${field}`,
+            "a finite numeric bound",
+            bound,
+            "numeric bound is invalid"
+          )
+        );
+      }
+    }
+    if (!numericType(typed.type) && (typed.minimum !== void 0 || typed.maximum !== void 0)) {
+      return failure2(
+        parameterFailure(
+          path,
+          "minimum/maximum only on numeric parameters",
+          typed,
+          "numeric bounds are not meaningful for this parameter type"
+        )
+      );
+    }
+    if (typed.minimum !== void 0 && typed.maximum !== void 0 && typed.minimum > typed.maximum) {
+      return failure2(
+        parameterFailure(path, "minimum <= maximum", typed, "numeric bounds are reversed")
+      );
+    }
+    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(Object.freeze(normalized));
+}
+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;
+}
+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 projectScriptablePackMeta(definition, sourcePath) {
+  return {
+    schemaVersion: "2.0.0",
+    kind: "scriptable-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 jsonParameterValue(value) {
+  return value instanceof Uint8Array ? AssetGuid.format(value) : value;
+}
+function validatePackDefinition(value, sourcePath) {
+  if (!isRecord(value))
+    return failure2(
+      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 failure2(
+      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 failure2(
+      parameterFailure(
+        "$.schemaVersion",
+        "the literal '2.0.0'",
+        value.schemaVersion,
+        "authoring source schema is unsupported"
+      )
+    );
+  }
+  if (!isPackageId(value.packageId)) {
+    return failure2(
+      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 failure2(
+      parameterFailure("$.name", "a string when present", value.name, "display name is malformed")
+    );
+  }
+  if (typeof value.build !== "function") {
+    return failure2(
+      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 hasPackParameters(value) {
+  return isRecord(value) && Array.isArray(value.parameters) && value.parameters.length > 0;
+}
+function resolvePackParameterValues(definition, overrides = {}, inheritedValues) {
+  if (!isRecord(overrides)) {
+    return failure2(
+      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 failure2(
+        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 failure2(
+    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 failure2(
+      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 failure2(
+      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 parsePackSourceJson(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 failure2(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 })
+  });
+}
+function projectDirectPackJson(value) {
+  const parsed = "format" in value ? ok(value) : parsePackSourceJson(value);
+  if (!parsed.ok) return parsed;
+  if (parsed.value.format !== "direct") {
+    return failure2(
+      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 failure2(
+        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 failure2(
+        authoringError(
+          "pack-parent-has-no-parameters",
+          "a ScriptablePack source with parameters as the parent",
+          "direct packs cannot be instance parents; point the instance at a ScriptablePack source with parameters",
+          { packageId: currentId }
+        )
+      );
+    }
+    if (current.format === "source") {
+      const descriptors2 = validateParameterDefinitions(current.parameters, "$.parameters");
+      if (!descriptors2.ok) return descriptors2;
+      if (descriptors2.value.length === 0) {
+        return failure2(
+          authoringError(
+            "pack-parent-has-no-parameters",
+            "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 failure2(
+        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 ScriptablePack with parameters",
+          { packageId: currentId, parent: PackageId.format(current.parent) }
+        )
+      );
+    }
+    if (PackageId.format(parent.packageId).toLowerCase() !== PackageId.format(current.parent).toLowerCase()) {
+      return failure2(
+        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 PACK_AUTHORING_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 createPackAuthoringGateway(port) {
+  const requests = /* @__PURE__ */ new Map();
+  return {
+    execute(operation) {
+      if (typeof operation.requestId !== "string" || operation.requestId.trim().length === 0) {
+        return Promise.resolve(
+          failure2(
+            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(
+          failure2(
+            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(
+          failure2(
+            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) => failure2(
+          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 PACK_AUTHORING_OPERATION_DESCRIPTORS = PACK_AUTHORING_OPERATION_IDS.map((id) => ({
+  id,
+  domain: id.startsWith("asset-source.") ? "session" : "asset",
+  readOnly: id.startsWith("asset."),
+  requiresRevision: !id.startsWith("asset.") && id !== "asset-source.create"
+}));
+function isRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(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"
     );
   }
   if ("provenance" in value) {
     const provenance = value.provenance;
-    if (!isRecord(provenance) || !hasText(provenance.provider) || !hasText(provenance.version)) {
+    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"
       );
@@ -7229,10 +8403,10 @@ function validateFacts(value, subjectId) {
   }
   if ("revision" in value) {
     const revision = value.revision;
-    if (!isRecord(revision) || !hasText(revision.digest) || !hasText(revision.rootId) || typeof revision.observedAt !== "number" || !Number.isFinite(revision.observedAt)) {
+    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"
       );
@@ -7242,25 +8416,25 @@ 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"
       );
     }
     for (const diagnostic of value.diagnostics) {
-      if (!isRecord(diagnostic) || !hasText(diagnostic.code)) {
+      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"
         );
       }
       if (diagnostic.severity === "blocking") {
-        if (!isRecord(diagnostic.subject) || !hasText(diagnostic.subject.id)) {
+        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"
           );
@@ -7268,7 +8442,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"
           );
@@ -7278,16 +8452,16 @@ 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) => isRecord(subAsset) && hasText(subAsset.sourceKey) ? [subAsset.sourceKey] : []
+    (subAsset) => isRecord2(subAsset) && hasText(subAsset.sourceKey) ? [subAsset.sourceKey] : []
   ) : [];
   const result = validateSourceOverrideMap(value.sourceOverrides, declaredSourceKeys);
   if (!result.ok) {
     return issue(
       result.error.code,
-      subjectId,
+      subjectId2,
       result.error.expected,
       result.error.hint,
       result.error.actual,
@@ -7300,7 +8474,7 @@ function validateMetaSourceOverrides(value, subjectId) {
   };
 }
 function validateProducerContract(value) {
-  if (!isRecord(value)) {
+  if (!isRecord2(value)) {
     return issue(
       "invalid-producer-fact",
       "unknown",
@@ -7308,15 +8482,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"
     );
@@ -7324,7 +8498,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"
     );
@@ -7334,7 +8508,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"
     );
@@ -7342,7 +8516,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"
     );
@@ -7350,7 +8524,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"
     );
@@ -7358,7 +8532,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"
     );
@@ -7396,93 +8570,6 @@ function validateProducerOutputs(outputs) {
   return { ok: true, value: outputs };
 }
 
-// src/errors.ts
-var PackError = class extends Error {
-  code;
-  expected;
-  hint;
-  detail;
-  constructor(args) {
-    super(`[PackError ${args.code}] expected: ${args.expected}; hint: ${args.hint}`);
-    this.name = "PackError";
-    this.code = args.code;
-    this.expected = args.expected;
-    this.hint = args.hint;
-    this.detail = args.detail;
-  }
-};
-
-// src/guid.ts
-function brand(bytes) {
-  return bytes;
-}
-var HEX_BYTE = Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, "0"));
-function bytesToDashForm(bytes) {
-  const h = HEX_BYTE;
-  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;
-function isValidAssetGuidString(value) {
-  return typeof value === "string" && UUID_RE.test(value);
-}
-function dashFormToBytes(dashForm) {
-  const hex = dashForm.replace(/-/g, "");
-  const bytes = new Uint8Array(16);
-  for (let i = 0; i < 16; i++) {
-    bytes[i] = parseInt(hex.slice(i * 2, i * 2 + 2), 16);
-  }
-  return bytes;
-}
-var AssetGuid = {
-  /**
-   * Parse a 36-char RFC 4122 dash-form UUID string into an AssetGuid.
-   * Returns Ok(AssetGuid) on success or Err(PackError) with code 'pack-guid-malformed' on failure.
-   * Never throws for expected failures (requirements §4.2 / §14 / charter proposition 4).
-   */
-  parse(dashForm) {
-    if (!isValidAssetGuidString(dashForm)) {
-      return {
-        ok: false,
-        error: new PackError({
-          code: "pack-guid-malformed",
-          expected: "36-char RFC 4122 dash-form UUID",
-          hint: "use AssetGuid.random() or a UUIDv7 generator; all GUID fields must be 36-char RFC 4122 dash-form",
-          detail: {
-            raw: dashForm,
-            reason: "expected 36-char RFC 4122 dash-form UUID"
-          }
-        })
-      };
-    }
-    return { ok: true, value: brand(dashFormToBytes(dashForm)) };
-  },
-  /**
-   * Format an AssetGuid as a 36-char RFC 4122 lowercase dash-form string.
-   */
-  format(guid) {
-    return bytesToDashForm(guid);
-  },
-  /**
-   * Test byte-by-byte equality between two AssetGuids.
-   */
-  equals(a, b) {
-    for (let i = 0; i < 16; i++) {
-      if (a[i] !== b[i]) return false;
-    }
-    return true;
-  },
-  /**
-   * Mint a new time-ordered UUIDv7 as an 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);
-  }
-};
-
 // src/scriptable-pack.ts
 var SCRIPTABLE_PACK_ASSET_KINDS = [
   "mesh",
@@ -7500,15 +8587,17 @@ var SCRIPTABLE_PACK_ASSET_KINDS = [
   "animation-clip",
   "animation-graph",
   "audio",
-  "particle-effect"
+  "particle-effect",
+  "ies-profile"
 ];
 function isScriptablePackAssetKind(value) {
   return SCRIPTABLE_PACK_ASSET_KINDS.includes(value);
 }
 function sceneComponentFieldType(value) {
   if (typeof value === "string") return value;
-  if (isRecord2(value) && typeof value.type === "string") return value.type;
-  return void 0;
+  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) => ({
@@ -7521,430 +8610,6 @@ function projectScriptablePackSceneComponents(components) {
     )
   }));
 }
-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];
-  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
-  };
-}
-[
-  {
-    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 invalid2(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 isRecord2(value) {
-  return value !== null && typeof value === "object" && !Array.isArray(value);
-}
-function isAssetGuid(value) {
-  return value instanceof Uint8Array && value.byteLength === 16;
-}
-function guidKey(guid) {
-  return AssetGuid.format(guid);
-}
-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()
-    ])
-  );
-  const sceneComponents = definition.sceneComponents === void 0 ? void 0 : Object.freeze(
-    projectScriptablePackSceneComponents(definition.sceneComponents).map(
-      (component) => Object.freeze({
-        ...component,
-        fields: Object.freeze({ ...component.fields })
-      })
-    )
-  );
-  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 (!isRecord2(value))
-    return invalid2("$", "a ScriptablePack definition object", value, sourcePath);
-  if (value.schemaVersion !== "1.0.0") {
-    return invalid2("$.schemaVersion", "the literal '1.0.0'", value.schemaVersion, sourcePath);
-  }
-  if (!isAssetGuid(value.packageId)) {
-    return invalid2("$.packageId", "a 16-byte AssetGuid", value.packageId, sourcePath);
-  }
-  if (value.name !== void 0 && typeof value.name !== "string") {
-    return invalid2("$.name", "a string when present", value.name, sourcePath);
-  }
-  if (!isRecord2(value.assets) || Object.keys(value.assets).length === 0) {
-    return invalid2(
-      "$.assets",
-      "a non-empty sourceKey to descriptor object",
-      value.assets,
-      sourcePath
-    );
-  }
-  if (!isRecord2(value.externalAssets)) {
-    return invalid2(
-      "$.externalAssets",
-      "an alias to AssetGuid object",
-      value.externalAssets,
-      sourcePath
-    );
-  }
-  if (value.sceneComponents !== void 0) {
-    if (!Array.isArray(value.sceneComponents)) {
-      return invalid2(
-        "$.sceneComponents",
-        "an array of component tokens or neutral schema rows when present",
-        value.sceneComponents,
-        sourcePath
-      );
-    }
-    const componentNames = /* @__PURE__ */ new Set();
-    for (const [componentIndex, component] of value.sceneComponents.entries()) {
-      if (!isRecord2(component)) {
-        return invalid2(
-          `$.sceneComponents[${componentIndex}]`,
-          "a component token or neutral schema row",
-          component,
-          sourcePath
-        );
-      }
-      if (typeof component.name !== "string" || component.name.trim().length === 0) {
-        return invalid2(
-          `$.sceneComponents[${componentIndex}].name`,
-          "a non-empty component name",
-          component.name,
-          sourcePath
-        );
-      }
-      if (componentNames.has(component.name)) {
-        return invalid2(
-          `$.sceneComponents[${componentIndex}].name`,
-          "component names to be unique within one ScriptablePack",
-          component.name,
-          sourcePath
-        );
-      }
-      componentNames.add(component.name);
-      if (!isRecord2(component.fields)) {
-        return invalid2(
-          `$.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 invalid2(
-            `$.sceneComponents[${componentIndex}].fields`,
-            "field names with non-empty string schema types",
-            field,
-            sourcePath
-          );
-        }
-      }
-    }
-  }
-  if (typeof value.build !== "function") {
-    return invalid2("$.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 invalid2("$.assets", "non-empty sourceKey object keys", sourceKey2, sourcePath);
-    }
-    if (!isRecord2(descriptor)) {
-      return invalid2(
-        `$.assets[${JSON.stringify(sourceKey2)}]`,
-        "an asset descriptor",
-        descriptor,
-        sourcePath
-      );
-    }
-    if (!isAssetGuid(descriptor.guid)) {
-      return invalid2(
-        `$.assets[${JSON.stringify(sourceKey2)}].guid`,
-        "a 16-byte AssetGuid",
-        descriptor.guid,
-        sourcePath
-      );
-    }
-    if (typeof descriptor.kind !== "string" || !isScriptablePackAssetKind(descriptor.kind)) {
-      return invalid2(
-        `$.assets[${JSON.stringify(sourceKey2)}].kind`,
-        "one of SCRIPTABLE_PACK_ASSET_KINDS",
-        descriptor.kind,
-        sourcePath
-      );
-    }
-    if (descriptor.name !== void 0 && typeof descriptor.name !== "string") {
-      return invalid2(
-        `$.assets[${JSON.stringify(sourceKey2)}].name`,
-        "a string when present",
-        descriptor.name,
-        sourcePath
-      );
-    }
-    const guid = guidKey(descriptor.guid);
-    if (guid === packageGuid || localGuids.has(guid)) {
-      return invalid2(
-        `$.assets[${JSON.stringify(sourceKey2)}].guid`,
-        "a GUID unique within the package and distinct from packageId",
-        descriptor.guid,
-        sourcePath
-      );
-    }
-    localGuids.add(guid);
-  }
-  const externalGuids = /* @__PURE__ */ new Set();
-  for (const [alias, guidValue] of Object.entries(value.externalAssets)) {
-    if (alias.trim().length === 0) {
-      return invalid2("$.externalAssets", "non-empty alias object keys", alias, sourcePath);
-    }
-    if (!isAssetGuid(guidValue)) {
-      return invalid2(
-        `$.externalAssets[${JSON.stringify(alias)}]`,
-        "a 16-byte AssetGuid",
-        guidValue,
-        sourcePath
-      );
-    }
-    const guid = guidKey(guidValue);
-    if (guid === packageGuid || localGuids.has(guid) || externalGuids.has(guid)) {
-      return invalid2(
-        `$.externalAssets[${JSON.stringify(alias)}]`,
-        "a unique foreign GUID not owned by this package",
-        guidValue,
-        sourcePath
-      );
-    }
-    externalGuids.add(guid);
-  }
-  return ok(freezeDefinition(value));
-}
-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
-  };
-}
 
 // src/topology.ts
 function sourceKey(output) {
@@ -8155,7 +8820,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",
@@ -8296,11 +8961,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",
@@ -8322,12 +8987,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 ScriptablePack packageId for one v3 instance; the source may declare Pack parameters."
+    },
+    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: {
@@ -8419,6 +9130,30 @@ var pack_schema_default = {
         }
       ]
     },
+    authoringAssets: {
+      type: "object",
+      additionalProperties: false,
+      patternProperties: {
+        "^[a-z0-9][a-z0-9._-]*(/[a-z0-9][a-z0-9._-]*)*$": {
+          $ref: "#/$defs/authoringAsset"
+        }
+      }
+    },
+    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,
@@ -8548,7 +9283,7 @@ function writeMaterialArtifact(input) {
     digest: createMaterialArtifactDigest(input.bytes)
   };
 }
-function invalid3(observed, expected) {
+function invalid2(observed, expected) {
   return err({
     code: "pack-v2-envelope-invalid",
     expected,
@@ -8567,10 +9302,10 @@ function isAsset(value) {
 }
 function projectRuntimePack(value) {
   if (!isRecord3(value) || ("schemaVersion" in value || "kind" in value) && (value.schemaVersion !== "2.0.0" || value.kind !== "internal-text-package")) {
-    return invalid3("legacy or malformed pack input", "runtime Pack v2");
+    return invalid2("legacy or malformed pack input", "runtime Pack v2");
   }
   if (!isTuple(value) || !Array.isArray(value.assets) || !value.assets.every(isAsset)) {
-    return invalid3("incomplete publication tuple or asset envelope", "verified runtime Pack v2");
+    return invalid2("incomplete publication tuple or asset envelope", "verified runtime Pack v2");
   }
   const seen = /* @__PURE__ */ new Set();
   for (const asset of value.assets) {
@@ -8609,6 +9344,6 @@ function parsePackV2(value) {
   return ok(value);
 }
 
-export { MESH_BIN_DIGEST_BYTES, MESH_BIN_HEADER_V4_BYTES, MESH_BIN_PROJECTION_VERSION, MESH_BIN_VERSION, SCRIPTABLE_PACK_ASSET_KINDS, buildOfflineAssetEvidence, calculateTopologyDiff, collectMaterialCookRefs, createMaterialArtifactDigest, createMaterialCookIdentity, decodeMeshBinHeader, diffTopology, isScriptablePackAssetKind, packageVerification, parsePackV2, projectCookedMaterialRecord, projectRuntimePack, projectScriptablePackMeta, serializeCookedMaterialRecord, serializeMaterialCookReceipt, validateArtifactPath, validateCookedMaterialRecord, validateMaterialCookReceipt, validateMeta, validatePack, validatePackV2, validateProducerContract, validateProducerOutputs, validateScriptablePackDefinition, writeMaterialArtifact, writeMeshBinHeader };
+export { AssetGuid, MESH_BIN_DIGEST_BYTES, MESH_BIN_HEADER_V4_BYTES, MESH_BIN_PROJECTION_VERSION, MESH_BIN_VERSION, PACK_AUTHORING_OPERATION_DESCRIPTORS, PACK_AUTHORING_OPERATION_IDS, PACK_PARAMETER_TYPES, PACK_SOURCE_KEY_RE, PackageId, SCRIPTABLE_PACK_ASSET_KINDS, buildOfflineAssetEvidence, calculateTopologyDiff, collectMaterialCookRefs, createMaterialArtifactDigest, createMaterialCookIdentity, createPackAuthoringGateway, decodeMeshBinHeader, definePack, definePackageId, diffTopology, hasPackParameters, isScriptablePackAssetKind, isStandardMaterialRecord, isStandardRootModule, isValidAssetGuidString, isValidPackSourceKey, materialLayerPlanIdentity, packageVerification, parsePackSourceJson, parsePackV2, projectCookedMaterialRecord, projectDirectPackJson, projectRuntimePack, projectScriptablePackMeta, projectScriptablePackSceneComponents, resolvePackInheritance, resolvePackParameterInheritance, resolvePackParameterValues, serializeCookedMaterialRecord, serializeMaterialCookReceipt, validateArtifactPath, validateCookedMaterialRecord, validateMaterialCookReceipt, validateMeta, validatePack, validatePackDefinition, validatePackV2, validateProducerContract, validateProducerOutputs, writeMaterialArtifact, writeMeshBinHeader };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map