@forgeax/engine-pack 0.1.21 → 0.1.23

package/dist/scanner.mjs

@@ -1,9 +1,10 @@
 import { createHash } from 'crypto';
 import { stat, readFile, readdir, realpath, mkdtemp, rm } from 'fs/promises';
-import { join, basename, dirname, resolve, posix, extname } from 'path';
-import { PACK_ERROR_HINTS, ok, err, validateSourceOverrideMap, AssetError, ImportError } from '@forgeax/engine-types';
-import { readFileSync, existsSync } from 'fs';
+import { join, basename, dirname, resolve, extname } from 'path';
+import { ok, PACK_ERROR_HINTS, err, validateSourceOverrideMap, AssetError, ImportError } from '@forgeax/engine-types';
+import { sha1 } from '@noble/hashes/legacy.js';
 import { uuidv7obj } from 'uuidv7';
+import { existsSync } from 'fs';
 import { tmpdir } from 'os';
 import { fileURLToPath } from 'url';
 import { Worker } from 'worker_threads';
@@ -3625,49 +3626,49 @@ var require_fast_uri = __commonJS({
       schemelessOptions.skipEscape = true;
       return serialize(resolved, schemelessOptions);
     }
-    function resolveComponent(base, relative2, options, skipNormalization) {
+    function resolveComponent(base, relative, options, skipNormalization) {
       const target = {};
       if (!skipNormalization) {
         base = parse(serialize(base, options), options);
-        relative2 = parse(serialize(relative2, options), options);
+        relative = parse(serialize(relative, options), options);
       }
       options = options || {};
-      if (!options.tolerant && relative2.scheme) {
-        target.scheme = relative2.scheme;
-        target.userinfo = relative2.userinfo;
-        target.host = relative2.host;
-        target.port = relative2.port;
-        target.path = removeDotSegments(relative2.path || "");
-        target.query = relative2.query;
+      if (!options.tolerant && relative.scheme) {
+        target.scheme = relative.scheme;
+        target.userinfo = relative.userinfo;
+        target.host = relative.host;
+        target.port = relative.port;
+        target.path = removeDotSegments(relative.path || "");
+        target.query = relative.query;
       } else {
-        if (relative2.userinfo !== void 0 || relative2.host !== void 0 || relative2.port !== void 0) {
-          target.userinfo = relative2.userinfo;
-          target.host = relative2.host;
-          target.port = relative2.port;
-          target.path = removeDotSegments(relative2.path || "");
-          target.query = relative2.query;
+        if (relative.userinfo !== void 0 || relative.host !== void 0 || relative.port !== void 0) {
+          target.userinfo = relative.userinfo;
+          target.host = relative.host;
+          target.port = relative.port;
+          target.path = removeDotSegments(relative.path || "");
+          target.query = relative.query;
         } else {
-          if (!relative2.path) {
+          if (!relative.path) {
             target.path = base.path;
-            if (relative2.query !== void 0) {
-              target.query = relative2.query;
+            if (relative.query !== void 0) {
+              target.query = relative.query;
             } else {
               target.query = base.query;
             }
           } else {
-            if (relative2.path[0] === "/") {
-              target.path = removeDotSegments(relative2.path);
+            if (relative.path[0] === "/") {
+              target.path = removeDotSegments(relative.path);
             } else {
               if ((base.userinfo !== void 0 || base.host !== void 0 || base.port !== void 0) && !base.path) {
-                target.path = "/" + relative2.path;
+                target.path = "/" + relative.path;
               } else if (!base.path) {
-                target.path = relative2.path;
+                target.path = relative.path;
               } else {
-                target.path = base.path.slice(0, base.path.lastIndexOf("/") + 1) + relative2.path;
+                target.path = base.path.slice(0, base.path.lastIndexOf("/") + 1) + relative.path;
               }
               target.path = removeDotSegments(target.path);
             }
-            target.query = relative2.query;
+            target.query = relative.query;
           }
           target.userinfo = base.userinfo;
           target.host = base.host;
@@ -3675,7 +3676,7 @@ var require_fast_uri = __commonJS({
         }
         target.scheme = base.scheme;
       }
-      target.fragment = relative2.fragment;
+      target.fragment = relative.fragment;
       return target;
     }
     function equal(uriA, uriB, options) {
@@ -4714,8 +4715,8 @@ var require_multipleOf = __commonJS({
         const { gen, data, schemaCode, it } = cxt;
         const prec = it.opts.multipleOfPrecision;
         const res = gen.let("res");
-        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}))`);
+        const invalid = 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}, ${invalid}))`);
       }
     };
     exports.default = def;
@@ -6820,27 +6821,6 @@ var require_dist = __commonJS({
     exports.default = formatsPlugin;
   }
 });
-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/errors.ts
 var PackError = class extends Error {
@@ -6866,6 +6846,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);
 }
@@ -6877,6 +6861,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, sourceKey) {
+  if (!(namespace instanceof Uint8Array) || namespace.byteLength !== 16) {
+    throw new TypeError("AssetGuid.derive requires a 16-byte PackageId");
+  }
+  if (!isValidPackSourceKey(sourceKey)) {
+    const error = new TypeError(
+      `AssetGuid.derive received invalid sourceKey ${JSON.stringify(sourceKey)}`
+    );
+    Object.defineProperty(error, "code", { value: "pack-source-key-invalid" });
+    throw error;
+  }
+  const name = new TextEncoder().encode(sourceKey);
+  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.
@@ -6920,19 +6946,760 @@ 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, sourceKey) {
+    return derivedGuid(namespace, sourceKey);
   }
 };
+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 failure(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 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 cloneValue(value) {
+  if (value instanceof Uint8Array) return value.slice();
+  if (Array.isArray(value)) return value.map((item) => cloneValue(item));
+  return value;
+}
+function sourceKeyFailure(sourceKey, 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 },
+    typeof sourceKey === "string" ? sourceKey : 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 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"
+        )
+      );
+    }
+    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 (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"
+        )
+      );
+    }
+    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"
+        )
+      );
+    }
+    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"
+        )
+      );
+    }
+    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 (!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"
+        )
+      );
+    }
+    if (typed.minimum !== void 0 && typed.maximum !== void 0 && typed.minimum > typed.maximum) {
+      return failure(
+        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 projectParameterizedPackMeta(definition, sourcePath) {
+  return {
+    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 jsonParameterValue(value) {
+  return value instanceof Uint8Array ? AssetGuid.format(value) : value;
+}
+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 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, sourceKey) {
+  if (!isRecord(value))
+    return jsonError(
+      `$.assets.${sourceKey}`,
+      "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.${sourceKey}.${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.${sourceKey}.kind`,
+      "a non-empty asset kind",
+      value.kind,
+      "asset kind is missing"
+    );
+  if (!isRecord(value.payload))
+    return jsonError(
+      `$.assets.${sourceKey}.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.${sourceKey}.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.${sourceKey}.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.${sourceKey}.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 [sourceKey, entry] of Object.entries(value.assets)) {
+      if (!isValidPackSourceKey(sourceKey))
+        return failure(sourceKeyFailure(sourceKey, `$.assets.${sourceKey}`));
+      const parsed = parsePackJsonAsset(entry, sourceKey);
+      if (!parsed.ok) return parsed;
+      assets[sourceKey] = 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) : 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 [sourceKey, entry] of Object.entries(parsed.value.assets).sort(
+    ([left], [right]) => left.localeCompare(right)
+  )) {
+    assets.push({
+      ...entry,
+      guid: AssetGuid.format(AssetGuid.derive(parsed.value.packageId, sourceKey)),
+      sourceKey
+    });
+  }
+  return ok({ packageId: PackageId.format(parsed.value.packageId), assets: Object.freeze(assets) });
+}
+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"
+];
+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"
+  })
+);
+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") {
+function issue(code, subjectId, expected, hint, actual, authority = "producer") {
   const subject = { type: "asset", id: subjectId };
   return {
     ok: false,
@@ -6940,7 +7707,7 @@ function issue(code, subjectId, expected, hint, actual2, authority = "producer")
       code,
       subject,
       expected,
-      ...actual2 === void 0 ? {} : { actual: actual2 },
+      ...actual === void 0 ? {} : { actual },
       hint,
       authority
     }
@@ -6957,7 +7724,7 @@ function validateFacts(value, subjectId) {
   }
   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,
@@ -6968,7 +7735,7 @@ 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,
@@ -6987,7 +7754,7 @@ function validateFacts(value, subjectId) {
       );
     }
     for (const diagnostic of value.diagnostics) {
-      if (!isRecord(diagnostic) || !hasText(diagnostic.code)) {
+      if (!isRecord2(diagnostic) || !hasText(diagnostic.code)) {
         return issue(
           "invalid-producer-fact",
           subjectId,
@@ -6996,7 +7763,7 @@ function validateFacts(value, subjectId) {
         );
       }
       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,
@@ -7020,7 +7787,7 @@ function validateFacts(value, subjectId) {
 function validateMetaSourceOverrides(value, subjectId) {
   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) {
@@ -7039,7 +7806,7 @@ function validateMetaSourceOverrides(value, subjectId) {
   };
 }
 function validateProducerContract(value) {
-  if (!isRecord(value)) {
+  if (!isRecord2(value)) {
     return issue(
       "invalid-producer-fact",
       "unknown",
@@ -7141,83 +7908,25 @@ function baseName(p) {
   const idx = Math.max(trimmed.lastIndexOf("/"), trimmed.lastIndexOf("\\"));
   return idx === -1 ? trimmed : trimmed.slice(idx + 1);
 }
-function deriveAssetName(packagePath, assetCount, storedName) {
+function deriveAssetName(packagePath, _assetCount, storedName) {
   if (packagePath === null) {
     return "";
   }
-  {
-    return baseName(packagePath);
-  }
+  return baseName(packagePath);
 }
 
 // src/resolve-asset-source.ts
 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);
     const derived = deriveSourceName(metaName);
-    return ok(resolve(metaDir, derived));
+    return 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 ok(resolve(dirname(metaPath), source));
+  return resolve(dirname(metaPath), source);
 }
 
 // src/schema-compiled.ts
@@ -7267,7 +7976,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",
@@ -7408,11 +8117,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",
@@ -7434,12 +8143,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: {
@@ -7531,6 +8286,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,
@@ -7638,467 +8417,6 @@ var ajv = new import_ajv.default({ strict: true, allErrors: false });
 (0, import_ajv_formats.default)(ajv, ["uuid"]);
 var validateMeta = ajv.compile(meta_schema_default);
 var validatePack = ajv.compile(pack_schema_default);
-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"
-];
-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;
-}
-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];
-  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 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 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(([sourceKey, descriptor]) => [
-      sourceKey,
-      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 invalid("$", "a ScriptablePack definition object", value, sourcePath);
-  if (value.schemaVersion !== "1.0.0") {
-    return invalid("$.schemaVersion", "the literal '1.0.0'", value.schemaVersion, sourcePath);
-  }
-  if (!isAssetGuid(value.packageId)) {
-    return invalid("$.packageId", "a 16-byte AssetGuid", value.packageId, sourcePath);
-  }
-  if (value.name !== void 0 && typeof value.name !== "string") {
-    return invalid("$.name", "a string when present", value.name, sourcePath);
-  }
-  if (!isRecord2(value.assets) || Object.keys(value.assets).length === 0) {
-    return invalid(
-      "$.assets",
-      "a non-empty sourceKey to descriptor object",
-      value.assets,
-      sourcePath
-    );
-  }
-  if (!isRecord2(value.externalAssets)) {
-    return invalid(
-      "$.externalAssets",
-      "an alias to AssetGuid object",
-      value.externalAssets,
-      sourcePath
-    );
-  }
-  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 componentNames = /* @__PURE__ */ new Set();
-    for (const [componentIndex, component] of value.sceneComponents.entries()) {
-      if (!isRecord2(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 (!isRecord2(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 (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 [sourceKey, descriptor] of Object.entries(value.assets)) {
-    if (sourceKey.trim().length === 0) {
-      return invalid("$.assets", "non-empty sourceKey object keys", sourceKey, sourcePath);
-    }
-    if (!isRecord2(descriptor)) {
-      return invalid(
-        `$.assets[${JSON.stringify(sourceKey)}]`,
-        "an asset descriptor",
-        descriptor,
-        sourcePath
-      );
-    }
-    if (!isAssetGuid(descriptor.guid)) {
-      return invalid(
-        `$.assets[${JSON.stringify(sourceKey)}].guid`,
-        "a 16-byte AssetGuid",
-        descriptor.guid,
-        sourcePath
-      );
-    }
-    if (typeof descriptor.kind !== "string" || !isScriptablePackAssetKind(descriptor.kind)) {
-      return invalid(
-        `$.assets[${JSON.stringify(sourceKey)}].kind`,
-        "one of SCRIPTABLE_PACK_ASSET_KINDS",
-        descriptor.kind,
-        sourcePath
-      );
-    }
-    if (descriptor.name !== void 0 && typeof descriptor.name !== "string") {
-      return invalid(
-        `$.assets[${JSON.stringify(sourceKey)}].name`,
-        "a string when present",
-        descriptor.name,
-        sourcePath
-      );
-    }
-    const guid = guidKey(descriptor.guid);
-    if (guid === packageGuid || localGuids.has(guid)) {
-      return invalid(
-        `$.assets[${JSON.stringify(sourceKey)}].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 invalid("$.externalAssets", "non-empty alias object keys", alias, sourcePath);
-    }
-    if (!isAssetGuid(guidValue)) {
-      return invalid(
-        `$.externalAssets[${JSON.stringify(alias)}]`,
-        "a 16-byte AssetGuid",
-        guidValue,
-        sourcePath
-      );
-    }
-    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
-      );
-    }
-    externalGuids.add(guid);
-  }
-  return ok(freezeDefinition(value));
-}
-function projectScriptablePackMeta(definition, source) {
-  const subAssets = Object.entries(definition.assets).sort(([left], [right]) => left.localeCompare(right)).map(([sourceKey, descriptor], sourceIndex) => ({
-    guid: guidKey(descriptor.guid),
-    sourceIndex,
-    sourceKey,
-    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
-  };
-}
 var IMPORT_META_RESOLVE_FLAG = "--experimental-import-meta-resolve";
 function scriptablePackWorkerExecArgv() {
   const inherited = process.execArgv.filter((arg) => !arg.startsWith("--input-type"));
@@ -8146,50 +8464,51 @@ async function inventoryScriptablePackSource(sourcePath, initialSourceText) {
 }
 function serializeFailure(value) {
   if (value !== null && typeof value === "object") {
-    const failure = value;
+    const failure2 = value;
     return {
-      name: failure.name,
-      code: failure.code,
-      expected: failure.expected,
-      actual: failure.actual,
-      hint: failure.hint,
-      detail: failure.detail,
-      message: failure.message
+      name: failure2.name,
+      code: failure2.code,
+      expected: failure2.expected,
+      actual: failure2.actual,
+      hint: failure2.hint,
+      detail: failure2.detail,
+      message: failure2.message
     };
   }
   return { message: String(value) };
 }
 function hydrateFailure(value) {
   if (value === null || typeof value !== "object") return value;
-  const failure = value;
-  if (failure.name === "AssetError" && typeof failure.code === "string" && typeof failure.expected === "string" && typeof failure.hint === "string") {
+  const failure2 = value;
+  if (failure2.name === "AssetError" && typeof failure2.code === "string" && typeof failure2.expected === "string" && typeof failure2.hint === "string") {
     const args = {
-      code: failure.code,
-      expected: failure.expected,
-      hint: failure.hint
+      code: failure2.code,
+      expected: failure2.expected,
+      hint: failure2.hint
     };
-    return failure.detail === void 0 ? new AssetError(args) : new AssetError({
+    return failure2.detail === void 0 ? new AssetError(args) : new AssetError({
       ...args,
-      detail: failure.detail
+      detail: failure2.detail
     });
   }
-  if (failure.name === "ImportError" && typeof failure.code === "string" && typeof failure.expected === "string" && typeof failure.hint === "string" && failure.detail !== void 0) {
+  if (failure2.name === "ImportError" && typeof failure2.code === "string" && typeof failure2.expected === "string" && typeof failure2.hint === "string" && failure2.detail !== void 0) {
     return new ImportError({
-      code: failure.code,
-      expected: failure.expected,
-      hint: failure.hint,
-      detail: failure.detail,
-      ...typeof failure.actual === "string" ? { actual: failure.actual } : {}
+      code: failure2.code,
+      expected: failure2.expected,
+      hint: failure2.hint,
+      detail: failure2.detail,
+      ...typeof failure2.actual === "string" ? { actual: failure2.actual } : {}
     });
   }
-  if (typeof failure.message === "string") {
-    const error = new Error(failure.message);
-    if (typeof failure.name === "string") error.name = failure.name;
+  if (typeof failure2.message === "string") {
+    const error = new Error(failure2.message);
+    if (typeof failure2.name === "string") error.name = failure2.name;
     return error;
   }
   return value;
 }
 var WorkerScriptablePackExecutor = class {
+  supportsParameterizedContext = true;
   worker;
   compileRoot;
   nextBuildId = 0;
@@ -8217,7 +8536,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") {
@@ -8249,7 +8568,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)
@@ -8257,7 +8576,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) {
@@ -8290,11 +8609,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,
@@ -8302,30 +8621,16 @@ 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) => {
@@ -8334,34 +8639,49 @@ async function loadScriptablePack(sourcePath, options = {}) {
     ]);
     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)),
+            Promise.resolve(invocation),
             new Promise((resolve3) => {
               buildTimeout = setTimeout(() => {
                 buildTimedOut = true;
@@ -8384,9 +8704,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);
@@ -8400,11 +8726,15 @@ function ok3(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",
@@ -8508,10 +8838,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(
@@ -8522,6 +8929,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(
@@ -8612,7 +9021,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;
@@ -8627,6 +9035,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,
@@ -8666,11 +9076,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 {
@@ -8690,23 +9096,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
             }
           ]
         })
@@ -8719,41 +9126,81 @@ async function scanValidated(roots, opts = {}, capture) {
       return packErr(
         makePackError("pack-malformed-meta", {
           path: sourcePath,
-          ajvErrors: [{ instancePath: "", message: "ScriptablePack source closure read failed" }]
+          ajvErrors: [{ instancePath: "", message: "Pack 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 }]
-        })
-      );
-    }
-    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();
@@ -8800,6 +9247,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,