@forgeax/engine-pack 0.1.21 → 0.1.24

package/dist/scriptable-pack-node.mjs

@@ -1,12 +1,13 @@
 import { createHash } from 'crypto';
 import { existsSync } from 'fs';
-import { realpath, readFile, stat, mkdtemp, rm, mkdir, writeFile, rename } from 'fs/promises';
+import { realpath, readFile, stat, mkdtemp, rm } from 'fs/promises';
 import { tmpdir } from 'os';
-import { resolve, dirname, extname, relative, sep, isAbsolute } from 'path';
+import { resolve, dirname, extname, relative, sep } from 'path';
 import { fileURLToPath } from 'url';
 import { Worker } from 'worker_threads';
-import { ok, err, AssetError, ImportError } from '@forgeax/engine-types';
+import { err, ok, AssetError, ImportError } from '@forgeax/engine-types';
 import ts from 'typescript';
+import { sha1 } from '@noble/hashes/legacy.js';
 import { uuidv7obj } from 'uuidv7';
 
 // src/scriptable-pack-node.ts
@@ -26,6 +27,8 @@ var PackError = class extends Error {
     this.detail = args.detail;
   }
 };
+
+// src/guid.ts
 function brand(bytes) {
   return bytes;
 }
@@ -35,6 +38,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);
 }
@@ -46,6 +53,33 @@ function dashFormToBytes(dashForm) {
   }
   return bytes;
 }
+function randomUuidBytes() {
+  const uuid = uuidv7obj();
+  const bytes = new Uint8Array(16);
+  bytes.set(uuid.bytes);
+  return bytes;
+}
+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.
@@ -89,473 +123,513 @@ 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 SCRIPTABLE_PACK_ASSET_KINDS = [
-  "mesh",
-  "material",
-  "scene",
-  "texture",
-  "equirect",
-  "sampler",
-  "font",
-  "render-pipeline",
-  "tileset",
-  "video",
-  "skeleton",
-  "skin",
-  "animation-clip",
-  "animation-graph",
-  "audio",
-  "particle-effect"
+
+// src/pack-authoring.ts
+var PACK_PARAMETER_TYPES = [
+  "bool",
+  "u32",
+  "i32",
+  "f32",
+  "f64",
+  "string",
+  "enum",
+  "vec2",
+  "vec3",
+  "vec4",
+  "color",
+  "asset-guid"
 ];
-function isScriptablePackAssetKind(value) {
-  return SCRIPTABLE_PACK_ASSET_KINDS.includes(value);
-}
-function sceneComponentFieldType(value) {
-  if (typeof value === "string") return value;
-  if (isRecord(value) && typeof value.type === "string") return value.type;
-  return void 0;
-}
-function projectScriptablePackSceneComponents(components) {
-  return (components ?? []).map((component) => ({
-    name: component.name,
-    fields: Object.fromEntries(
-      Object.entries(component.fields).map(([fieldName, field]) => [
-        fieldName,
-        sceneComponentFieldType(field)
-      ])
-    )
-  }));
-}
-var SCRIPTABLE_PACK_REQUEST_ID_SCHEMA = {
-  type: "string",
-  minLength: 1,
-  maxLength: 128,
-  pattern: "^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$",
-  description: "Caller-minted identity for one idempotent ScriptablePack operation."
-};
-var SCRIPTABLE_PACK_SOURCE_PATH_SCHEMA = {
-  type: "string",
-  minLength: 8,
-  pattern: "^[^/].*\\.pack\\.ts$",
-  description: "Game-root-relative ScriptablePack source path."
-};
-var SCRIPTABLE_PACK_OWNER_GUID_SCHEMA = {
-  type: "string",
-  format: "uuid",
-  description: "Catalog GUID used to resolve the producer-owned source subject."
-};
-var SCRIPTABLE_PACK_REVISION_SCHEMA = {
-  type: "string",
-  minLength: 64,
-  maxLength: 64,
-  pattern: "^[a-f0-9]{64}$",
-  description: "SHA-256 source revision returned by preflight."
-};
-var SCRIPTABLE_PACK_SOURCE_KEY_SCHEMA = { type: "string", minLength: 1 };
-var SCRIPTABLE_PACK_ASSET_KIND_SCHEMA = {
-  enum: SCRIPTABLE_PACK_ASSET_KINDS,
-  description: "Ordinary Asset kind supported by the ScriptablePack producer/loader matrix."
-};
-var SCRIPTABLE_PACK_NAME_SCHEMA = { type: "string", minLength: 1 };
-function scriptablePackArgsSchema(properties, required, options = {}) {
-  const subjectRequired = ["requestId", ...required];
+function authoringError(code, expected, hint, detail = {}, actual) {
   return {
-    type: "object",
-    properties: {
-      sourcePath: SCRIPTABLE_PACK_SOURCE_PATH_SCHEMA,
-      ownerGuid: SCRIPTABLE_PACK_OWNER_GUID_SCHEMA,
-      requestId: SCRIPTABLE_PACK_REQUEST_ID_SCHEMA,
-      ...properties
-    },
-    required: subjectRequired,
-    ...options.subject === false ? {} : {
-      anyOf: [
-        { required: [...subjectRequired, "sourcePath"] },
-        { required: [...subjectRequired, "ownerGuid"] },
-        ...options.guidSubject === false ? [] : [{ required: [...subjectRequired, "guid"] }]
-      ]
-    },
-    additionalProperties: false
+    code,
+    expected,
+    hint,
+    ...actual === void 0 ? {} : { actual },
+    detail
   };
 }
-[
-  {
-    id: "asset-source.create",
-    kind: "create",
-    domain: "session",
-    title: "Create Asset Source",
-    argsSchema: scriptablePackArgsSchema(
-      {
-        name: SCRIPTABLE_PACK_NAME_SCHEMA,
-        initialOutput: {
-          type: "object",
-          properties: {
-            sourceKey: SCRIPTABLE_PACK_SOURCE_KEY_SCHEMA,
-            kind: SCRIPTABLE_PACK_ASSET_KIND_SCHEMA,
-            name: SCRIPTABLE_PACK_NAME_SCHEMA
-          },
-          required: ["sourceKey", "kind"],
-          additionalProperties: false
-        }
-      },
-      ["sourcePath", "initialOutput"],
-      { subject: false }
-    )
-  },
-  {
-    id: "asset-source.add-output",
-    kind: "add-output",
-    domain: "session",
-    title: "Add Asset Source Output",
-    argsSchema: scriptablePackArgsSchema(
-      {
-        sourceKey: SCRIPTABLE_PACK_SOURCE_KEY_SCHEMA,
-        assetKind: SCRIPTABLE_PACK_ASSET_KIND_SCHEMA,
-        name: SCRIPTABLE_PACK_NAME_SCHEMA,
-        expectedRevision: SCRIPTABLE_PACK_REVISION_SCHEMA
-      },
-      ["sourceKey", "assetKind", "expectedRevision"]
-    )
-  },
-  {
-    id: "asset-source.add-external-asset",
-    kind: "add-external-asset",
-    domain: "session",
-    title: "Add Asset Source External Asset",
-    argsSchema: scriptablePackArgsSchema(
-      {
-        alias: SCRIPTABLE_PACK_SOURCE_KEY_SCHEMA,
-        guid: { type: "string", format: "uuid" },
-        expectedRevision: SCRIPTABLE_PACK_REVISION_SCHEMA
-      },
-      ["alias", "guid", "expectedRevision"],
-      { guidSubject: false }
-    )
-  },
-  {
-    id: "asset-source.rename",
-    kind: "rename",
-    domain: "session",
-    title: "Rename Asset Source Display Name",
-    argsSchema: scriptablePackArgsSchema(
-      {
-        target: {
-          oneOf: [
-            {
-              type: "object",
-              properties: { kind: { const: "package" } },
-              required: ["kind"],
-              additionalProperties: false
-            },
-            {
-              type: "object",
-              properties: {
-                kind: { const: "output" },
-                sourceKey: SCRIPTABLE_PACK_SOURCE_KEY_SCHEMA
-              },
-              required: ["kind", "sourceKey"],
-              additionalProperties: false
-            }
-          ]
-        },
-        name: SCRIPTABLE_PACK_NAME_SCHEMA,
-        expectedRevision: SCRIPTABLE_PACK_REVISION_SCHEMA
-      },
-      ["target", "name", "expectedRevision"]
-    )
-  },
-  {
-    id: "asset-source.remove-output",
-    kind: "remove-output",
-    domain: "session",
-    title: "Remove Asset Source Output",
-    destructive: true,
-    argsSchema: scriptablePackArgsSchema(
-      {
-        sourceKey: SCRIPTABLE_PACK_SOURCE_KEY_SCHEMA,
-        confirmIncomingRefs: { type: "array", items: { type: "string" } },
-        expectedRevision: SCRIPTABLE_PACK_REVISION_SCHEMA
-      },
-      ["sourceKey", "expectedRevision"]
-    )
-  },
-  {
-    id: "asset-source.clone",
-    kind: "clone",
-    domain: "session",
-    title: "Clone Asset Source",
-    argsSchema: scriptablePackArgsSchema(
-      {
-        targetPath: SCRIPTABLE_PACK_SOURCE_PATH_SCHEMA,
-        expectedRevision: SCRIPTABLE_PACK_REVISION_SCHEMA
-      },
-      ["targetPath", "expectedRevision"]
-    )
-  },
-  {
-    id: "asset-source.rebuild",
-    kind: "rebuild",
-    domain: "session",
-    title: "Rebuild Asset Source",
-    argsSchema: scriptablePackArgsSchema({ expectedRevision: SCRIPTABLE_PACK_REVISION_SCHEMA }, [
-      "expectedRevision"
-    ])
-  },
-  {
-    id: "asset-source.cold-cook",
-    kind: "cold-cook",
-    domain: "session",
-    title: "Cold Cook Asset Source",
-    argsSchema: scriptablePackArgsSchema({ expectedRevision: SCRIPTABLE_PACK_REVISION_SCHEMA }, [
-      "expectedRevision"
-    ])
-  }
-];
-function actual(value) {
-  if (value === null) return "null";
-  if (Array.isArray(value)) return "array";
-  if (ArrayBuffer.isView(value)) return value.constructor.name;
-  return typeof value;
-}
-function invalid(propertyPath, expected, value, sourcePath) {
-  return err({
-    code: "pack-source-definition-invalid",
-    expected,
-    hint: "repair the default exported ScriptablePack definition, then inspect Meta again",
-    detail: {
-      ...sourcePath === void 0 ? {} : { sourcePath },
-      propertyPath,
-      actual: actual(value)
-    }
-  });
+function failure(error) {
+  return err(error);
 }
 function isRecord(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
-function isAssetGuid(value) {
+function validateSceneComponents(value) {
+  if (value === void 0) return ok(void 0);
+  if (!Array.isArray(value)) {
+    return failure(
+      parameterFailure(
+        "$.sceneComponents",
+        "an array of component schema records",
+        value,
+        "sceneComponents is not an array"
+      )
+    );
+  }
+  const components = [];
+  const names = /* @__PURE__ */ new Set();
+  for (const [componentIndex, candidate] of value.entries()) {
+    if (!isRecord(candidate) || typeof candidate.name !== "string" || !isRecord(candidate.fields)) {
+      return failure(
+        parameterFailure(
+          `$.sceneComponents[${componentIndex}]`,
+          "a component record with name and fields",
+          candidate,
+          "scene component schema is malformed"
+        )
+      );
+    }
+    if (candidate.name.length === 0 || names.has(candidate.name)) {
+      return failure(
+        parameterFailure(
+          `$.sceneComponents[${componentIndex}].name`,
+          "a non-empty unique component name",
+          candidate.name,
+          "scene component names must be unique"
+        )
+      );
+    }
+    names.add(candidate.name);
+    const fields = {};
+    for (const [fieldName, field] of Object.entries(candidate.fields)) {
+      if (typeof field === "string" && field.length === 0 || typeof field !== "string" && (!isRecord(field) || typeof field.type !== "string" || field.type.length === 0)) {
+        return failure(
+          parameterFailure(
+            `$.sceneComponents[${componentIndex}].fields.${fieldName}`,
+            "a field type string or { type: string }",
+            field,
+            "scene component field schema is malformed"
+          )
+        );
+      }
+      fields[fieldName] = field;
+    }
+    components.push({ name: candidate.name, fields });
+  }
+  return ok(components);
+}
+function isPackageId(value) {
   return value instanceof Uint8Array && value.byteLength === 16;
 }
-function guidKey(guid) {
-  return AssetGuid.format(guid);
+function cloneValue(value) {
+  if (value instanceof Uint8Array) return value.slice();
+  if (Array.isArray(value)) return value.map((item) => cloneValue(item));
+  return value;
 }
-function freezeDefinition(definition) {
-  const assets = Object.fromEntries(
-    Object.entries(definition.assets).map(([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 })
-      })
-    )
+function parameterFailure(propertyPath, expected, actual, reason) {
+  return authoringError(
+    "pack-parameter-invalid",
+    expected,
+    "repair the parameter declaration or the instance values, then inspect and rebuild",
+    { propertyPath, reason, actual: typeof actual === "string" ? actual : JSON.stringify(actual) }
   );
-  return Object.freeze({
-    ...definition,
-    packageId: definition.packageId.slice(),
-    assets: Object.freeze(assets),
-    externalAssets: Object.freeze(externalAssets),
-    ...sceneComponents === void 0 ? {} : { sceneComponents }
-  });
 }
-function validateScriptablePackDefinition(value, sourcePath) {
-  if (!isRecord(value))
-    return invalid("$", "a ScriptablePack definition object", value, sourcePath);
-  if (value.schemaVersion !== "1.0.0") {
-    return invalid("$.schemaVersion", "the literal '1.0.0'", value.schemaVersion, sourcePath);
+function numericType(type) {
+  return type === "u32" || type === "i32" || type === "f32" || type === "f64";
+}
+function vectorLength(type) {
+  switch (type) {
+    case "vec2":
+      return 2;
+    case "vec3":
+      return 3;
+    case "vec4":
+    case "color":
+      return 4;
+    default:
+      return void 0;
   }
-  if (!isAssetGuid(value.packageId)) {
-    return invalid("$.packageId", "a 16-byte AssetGuid", value.packageId, sourcePath);
+}
+function parameterValueError(parameter, value, propertyPath) {
+  const { type } = parameter;
+  if (type === "bool" && typeof value !== "boolean") {
+    return parameterFailure(propertyPath, "a boolean", value, "bool value has the wrong type");
   }
-  if (value.name !== void 0 && typeof value.name !== "string") {
-    return invalid("$.name", "a string when present", value.name, sourcePath);
+  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 (!isRecord(value.assets) || Object.keys(value.assets).length === 0) {
-    return invalid(
-      "$.assets",
-      "a non-empty sourceKey to descriptor object",
-      value.assets,
-      sourcePath
-    );
+  if (type === "string" && typeof value !== "string") {
+    return parameterFailure(propertyPath, "a string", value, "string parameter has the wrong type");
   }
-  if (!isRecord(value.externalAssets)) {
-    return invalid(
-      "$.externalAssets",
-      "an alias to AssetGuid object",
-      value.externalAssets,
-      sourcePath
-    );
+  if (type === "enum") {
+    if (typeof value !== "string") {
+      return parameterFailure(
+        propertyPath,
+        "one of the declared enum strings",
+        value,
+        "enum value has the wrong type"
+      );
+    }
+    if (parameter.values === void 0 || !parameter.values.includes(value)) {
+      return parameterFailure(
+        propertyPath,
+        "one of the declared enum values",
+        value,
+        "enum value is not declared"
+      );
+    }
+    return void 0;
   }
-  if (value.sceneComponents !== void 0) {
-    if (!Array.isArray(value.sceneComponents)) {
-      return invalid(
-        "$.sceneComponents",
-        "an array of component tokens or neutral schema rows when present",
-        value.sceneComponents,
-        sourcePath
+  const length = vectorLength(type);
+  if (length !== void 0) {
+    if (!Array.isArray(value) || value.length !== length || value.some((component) => typeof component !== "number" || !Number.isFinite(component))) {
+      return parameterFailure(
+        propertyPath,
+        `a finite numeric vector with ${length} components`,
+        value,
+        "vector value has the wrong shape"
       );
     }
-    const componentNames = /* @__PURE__ */ new Set();
-    for (const [componentIndex, component] of value.sceneComponents.entries()) {
-      if (!isRecord(component)) {
-        return invalid(
-          `$.sceneComponents[${componentIndex}]`,
-          "a component token or neutral schema row",
-          component,
-          sourcePath
-        );
-      }
-      if (typeof component.name !== "string" || component.name.trim().length === 0) {
-        return invalid(
-          `$.sceneComponents[${componentIndex}].name`,
-          "a non-empty component name",
-          component.name,
-          sourcePath
-        );
-      }
-      if (componentNames.has(component.name)) {
-        return invalid(
-          `$.sceneComponents[${componentIndex}].name`,
-          "component names to be unique within one ScriptablePack",
-          component.name,
-          sourcePath
-        );
-      }
-      componentNames.add(component.name);
-      if (!isRecord(component.fields)) {
-        return invalid(
-          `$.sceneComponents[${componentIndex}].fields`,
-          "a field-name to schema-type object",
-          component.fields,
-          sourcePath
-        );
-      }
-      for (const [fieldName, field] of Object.entries(component.fields)) {
-        const type = sceneComponentFieldType(field);
-        if (fieldName.trim().length === 0 || type === void 0 || type.trim().length === 0) {
-          return invalid(
-            `$.sceneComponents[${componentIndex}].fields`,
-            "field names with non-empty string schema types",
-            field,
-            sourcePath
-          );
-        }
-      }
+    if (type === "color" && value.some((component) => component < 0 || component > 1)) {
+      return parameterFailure(
+        propertyPath,
+        "an RGBA color with components in [0, 1]",
+        value,
+        "color component is outside [0, 1]"
+      );
     }
+    return void 0;
   }
-  if (typeof value.build !== "function") {
-    return invalid("$.build", "a build(assetReader) function", value.build, sourcePath);
+  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;
   }
-  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);
+  return parameterFailure(
+    propertyPath,
+    "a supported Pack parameter type",
+    value,
+    "unknown parameter type"
+  );
+}
+function normalizeParameterValue(parameter, value, propertyPath) {
+  const error = parameterValueError(parameter, value, propertyPath);
+  if (error !== void 0) return failure(error);
+  if (parameter.type === "asset-guid" && typeof value === "string") {
+    const parsed = AssetGuid.parse(value);
+    if (!parsed.ok) {
+      return failure(
+        parameterFailure(
+          propertyPath,
+          "a valid AssetGuid UUID string",
+          value,
+          "asset GUID parser rejected the value"
+        )
+      );
     }
-    if (!isRecord(descriptor)) {
-      return invalid(
-        `$.assets[${JSON.stringify(sourceKey)}]`,
-        "an asset descriptor",
-        descriptor,
-        sourcePath
+    return ok(parsed.value);
+  }
+  return ok(cloneValue(value));
+}
+function validateParameterDefinitions(parameters, propertyPath = "$.parameters") {
+  if (!Array.isArray(parameters) || parameters.length === 0) {
+    return failure(
+      parameterFailure(
+        propertyPath,
+        "a non-empty parameter descriptor array",
+        parameters,
+        "parameters must be explicit and non-empty"
+      )
+    );
+  }
+  const names = /* @__PURE__ */ new Set();
+  const normalized = [];
+  for (const [index, candidate] of parameters.entries()) {
+    const path = `${propertyPath}[${index}]`;
+    if (!isRecord(candidate))
+      return failure(
+        parameterFailure(
+          path,
+          "a parameter descriptor object",
+          candidate,
+          "descriptor is not an object"
+        )
+      );
+    const name = candidate.name;
+    if (typeof name !== "string" || !/^[A-Za-z][A-Za-z0-9_.-]*$/.test(name)) {
+      return failure(
+        parameterFailure(
+          `${path}.name`,
+          "a unique identifier-like parameter name",
+          name,
+          "parameter name is invalid"
+        )
       );
     }
-    if (!isAssetGuid(descriptor.guid)) {
-      return invalid(
-        `$.assets[${JSON.stringify(sourceKey)}].guid`,
-        "a 16-byte AssetGuid",
-        descriptor.guid,
-        sourcePath
+    if (names.has(name))
+      return failure(
+        parameterFailure(
+          `${path}.name`,
+          "a unique parameter name",
+          name,
+          "parameter name is duplicated"
+        )
+      );
+    names.add(name);
+    const unknown = Object.keys(candidate).find(
+      (key) => !["name", "type", "default", "minimum", "maximum", "values", "kind"].includes(key)
+    );
+    if (unknown !== void 0) {
+      return failure(
+        parameterFailure(
+          `${path}.${unknown}`,
+          "only name, type, default, minimum, maximum, values, and kind fields",
+          candidate[unknown],
+          "parameter descriptors are a closed authoring schema"
+        )
       );
     }
-    if (typeof descriptor.kind !== "string" || !isScriptablePackAssetKind(descriptor.kind)) {
-      return invalid(
-        `$.assets[${JSON.stringify(sourceKey)}].kind`,
-        "one of SCRIPTABLE_PACK_ASSET_KINDS",
-        descriptor.kind,
-        sourcePath
+    const type = candidate.type;
+    if (typeof type !== "string" || !PACK_PARAMETER_TYPES.includes(type)) {
+      return failure(
+        parameterFailure(
+          `${path}.type`,
+          PACK_PARAMETER_TYPES.join(" | "),
+          type,
+          "parameter type is not supported"
+        )
       );
     }
-    if (descriptor.name !== void 0 && typeof descriptor.name !== "string") {
-      return invalid(
-        `$.assets[${JSON.stringify(sourceKey)}].name`,
-        "a string when present",
-        descriptor.name,
-        sourcePath
+    const typed = {
+      ...candidate,
+      name,
+      type
+    };
+    if (typed.values !== void 0) {
+      if (typed.type !== "enum" || !Array.isArray(typed.values) || typed.values.length === 0 || typed.values.some((item) => typeof item !== "string") || new Set(typed.values).size !== typed.values.length) {
+        return failure(
+          parameterFailure(
+            `${path}.values`,
+            "unique non-empty strings for enum",
+            typed.values,
+            "enum values are malformed"
+          )
+        );
+      }
+    } else if (typed.type === "enum") {
+      return failure(
+        parameterFailure(
+          `${path}.values`,
+          "a non-empty enum choices array",
+          typed.values,
+          "enum has no choices"
+        )
       );
     }
-    const guid = guidKey(descriptor.guid);
-    if (guid === packageGuid || localGuids.has(guid)) {
-      return invalid(
-        `$.assets[${JSON.stringify(sourceKey)}].guid`,
-        "a GUID unique within the package and distinct from packageId",
-        descriptor.guid,
-        sourcePath
+    if (typed.kind !== void 0 && (typed.type !== "asset-guid" || typeof typed.kind !== "string")) {
+      return failure(
+        parameterFailure(
+          `${path}.kind`,
+          "a kind constraint only on asset-guid parameters",
+          typed.kind,
+          "kind is misplaced"
+        )
       );
     }
-    localGuids.add(guid);
-  }
-  const externalGuids = /* @__PURE__ */ new Set();
-  for (const [alias, guidValue] of Object.entries(value.externalAssets)) {
-    if (alias.trim().length === 0) {
-      return invalid("$.externalAssets", "non-empty alias object keys", alias, sourcePath);
+    for (const field of ["minimum", "maximum"]) {
+      const bound = typed[field];
+      if (bound !== void 0 && (typeof bound !== "number" || !Number.isFinite(bound))) {
+        return failure(
+          parameterFailure(
+            `${path}.${field}`,
+            "a finite numeric bound",
+            bound,
+            "numeric bound is invalid"
+          )
+        );
+      }
     }
-    if (!isAssetGuid(guidValue)) {
-      return invalid(
-        `$.externalAssets[${JSON.stringify(alias)}]`,
-        "a 16-byte AssetGuid",
-        guidValue,
-        sourcePath
+    if (!numericType(typed.type) && (typed.minimum !== void 0 || typed.maximum !== void 0)) {
+      return failure(
+        parameterFailure(
+          path,
+          "minimum/maximum only on numeric parameters",
+          typed,
+          "numeric bounds are not meaningful for this parameter type"
+        )
       );
     }
-    const guid = guidKey(guidValue);
-    if (guid === packageGuid || localGuids.has(guid) || externalGuids.has(guid)) {
-      return invalid(
-        `$.externalAssets[${JSON.stringify(alias)}]`,
-        "a unique foreign GUID not owned by this package",
-        guidValue,
-        sourcePath
+    if (typed.minimum !== void 0 && typed.maximum !== void 0 && typed.minimum > typed.maximum) {
+      return failure(
+        parameterFailure(path, "minimum <= maximum", typed, "numeric bounds are reversed")
       );
     }
-    externalGuids.add(guid);
+    const defaultResult = normalizeParameterValue(typed, typed.default, `${path}.default`);
+    if (!defaultResult.ok) return defaultResult;
+    normalized.push({
+      ...typed,
+      default: defaultResult.value,
+      ...typed.values === void 0 ? {} : { values: Object.freeze([...typed.values]) }
+    });
   }
-  return ok(freezeDefinition(value));
+  return ok(Object.freeze(normalized));
 }
-function projectScriptablePackMeta(definition, source) {
-  const subAssets = Object.entries(definition.assets).sort(([left], [right]) => left.localeCompare(right)).map(([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
-  };
+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
+    })
+  );
 }
+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"
+];
+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"
+}));
 
 // src/evidence/source-inventory.ts
 function stableValue(value) {
@@ -651,50 +725,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 {
+  supportsPackParameters = true;
   worker;
   compileRoot;
   nextBuildId = 0;
@@ -722,7 +797,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") {
@@ -754,7 +829,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)
@@ -762,7 +837,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) {
@@ -820,6 +895,7 @@ var ReusableWorkerScriptablePackExecutor = class {
   }
   maxTasksPerWorker;
   release;
+  supportsPackParameters = true;
   worker;
   compileRootReady = mkdtemp(resolve(tmpdir(), "forgeax-scriptable-pack-pool-"));
   compileRoot;
@@ -903,7 +979,7 @@ var ReusableWorkerScriptablePackExecutor = class {
     this.build = void 0;
     building?.reject(error);
   }
-  runBuild(reader) {
+  runBuild(reader, context) {
     if (this.released || this.disposal !== void 0) {
       return Promise.reject(new Error("ScriptablePack executor is not leased"));
     }
@@ -914,7 +990,7 @@ var ReusableWorkerScriptablePackExecutor = class {
     return new Promise((resolveBuild, rejectBuild) => {
       this.build = { id, reader, resolve: resolveBuild, reject: rejectBuild };
       try {
-        this.worker.postMessage({ kind: "build", buildId: id });
+        this.worker.postMessage({ kind: "build", buildId: id, context });
       } catch (error) {
         this.build = void 0;
         rejectBuild(error);
@@ -931,7 +1007,7 @@ var ReusableWorkerScriptablePackExecutor = class {
       loading.resolve({
         default: value.definition === void 0 ? void 0 : {
           ...value.definition,
-          build: (reader) => this.runBuild(reader)
+          build: (readByGuid, context) => this.runBuild({ readByGuid }, context)
         }
       });
       return;
@@ -1036,11 +1112,11 @@ var DefaultScriptablePackModuleExecutorPool = class {
 function createScriptablePackModuleExecutorPool(options = {}) {
   return new DefaultScriptablePackModuleExecutorPool(options);
 }
-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 scriptablePackLoadFailure(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,
@@ -1048,20 +1124,6 @@ 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 = {}) {
@@ -1080,34 +1142,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(
+        scriptablePackLoadFailure(
+          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(
+          scriptablePackLoadFailure(
+            sourcePath,
+            "timeout",
+            "build",
+            `ScriptablePack build exceeded ${buildTimeoutMs}ms`,
+            buildTimeoutMs
+          )
+        );
         try {
+          const invocation = "supportsPackParameters" in executor && executor.supportsPackParameters === 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;
@@ -1130,545 +1207,21 @@ 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(
+      scriptablePackLoadFailure(
+        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);
   }
 }
-var CANONICAL_SCAFFOLD_MARKER = "// @forgeax-scriptable-pack canonical-v1";
-var CANONICAL_MANIFEST_NAME = "canonicalManifest";
-var CANONICAL_MUTABLE_KINDS = /* @__PURE__ */ new Set(["scene", "mesh", "material"]);
-function authoringError(code, input) {
-  return {
-    code,
-    expected: input.expected,
-    ...input.actual === void 0 ? {} : { actual: input.actual },
-    hint: input.hint,
-    retryable: input.retryable,
-    recoveryActions: input.recoveryActions,
-    detail: {
-      ...input.requestId === void 0 ? {} : { requestId: input.requestId },
-      ...input.sourcePath === void 0 ? {} : { sourcePath: input.sourcePath },
-      ...input.sourceKey === void 0 ? {} : { sourceKey: input.sourceKey },
-      ...input.incomingRefs === void 0 ? {} : { incomingRefs: input.incomingRefs }
-    }
-  };
-}
-function confinedSourcePath(gameRoot, sourcePath) {
-  const root = resolve(gameRoot);
-  const absolute = resolve(root, sourcePath);
-  const rel = relative(root, absolute);
-  if (rel.length === 0 || rel === ".." || rel.startsWith(`..${sep}`) || isAbsolute(sourcePath) || !rel.endsWith(".pack.ts")) {
-    return err(
-      authoringError("pack-source-path-invalid", {
-        expected: "a game-root-relative *.pack.ts path confined to the selected game",
-        actual: sourcePath,
-        hint: "choose a relative ScriptablePack source path inside the selected game root",
-        retryable: false,
-        recoveryActions: ["choose-game-relative-source-path"],
-        sourcePath
-      })
-    );
-  }
-  return ok({ absolute, relative: rel.split(sep).join("/") });
-}
-function revisionOf(source) {
-  return createHash("sha256").update(source).digest("hex");
-}
-function unwrapExpression(expression) {
-  if (ts.isAsExpression(expression) || ts.isSatisfiesExpression(expression) || ts.isParenthesizedExpression(expression)) {
-    return unwrapExpression(expression.expression);
-  }
-  return expression;
-}
-function literalValue(expression) {
-  const value = unwrapExpression(expression);
-  if (ts.isStringLiteral(value) || ts.isNoSubstitutionTemplateLiteral(value)) return value.text;
-  if (value.kind === ts.SyntaxKind.TrueKeyword) return true;
-  if (value.kind === ts.SyntaxKind.FalseKeyword) return false;
-  if (value.kind === ts.SyntaxKind.NullKeyword) return null;
-  if (ts.isNumericLiteral(value)) return Number(value.text);
-  if (ts.isArrayLiteralExpression(value)) return value.elements.map(literalValue);
-  if (ts.isObjectLiteralExpression(value)) {
-    const result = {};
-    for (const property of value.properties) {
-      if (!ts.isPropertyAssignment(property))
-        throw new TypeError("manifest properties must be data");
-      const name = property.name;
-      const key = ts.isIdentifier(name) || ts.isStringLiteral(name) || ts.isNumericLiteral(name) ? name.text : void 0;
-      if (key === void 0) throw new TypeError("manifest property names must be static");
-      result[key] = literalValue(property.initializer);
-    }
-    return result;
-  }
-  throw new TypeError("manifest values must be literal data");
-}
-function parseCanonicalManifest(source, sourcePath) {
-  if (!source.startsWith(`${CANONICAL_SCAFFOLD_MARKER}
-`)) return void 0;
-  const file = ts.createSourceFile(
-    sourcePath,
-    source,
-    ts.ScriptTarget.Latest,
-    true,
-    ts.ScriptKind.TS
-  );
-  for (const statement of file.statements) {
-    if (!ts.isVariableStatement(statement)) continue;
-    for (const declaration of statement.declarationList.declarations) {
-      if (ts.isIdentifier(declaration.name) && declaration.name.text === CANONICAL_MANIFEST_NAME && declaration.initializer !== void 0) {
-        const value = literalValue(declaration.initializer);
-        if (value === null || typeof value !== "object") return void 0;
-        return value;
-      }
-    }
-  }
-  return void 0;
-}
-function guidExpression(value) {
-  return `parseGuid(${JSON.stringify(value)})`;
-}
-function renderCanonicalScriptablePack(manifest) {
-  const data = JSON.stringify(manifest, null, 2);
-  return `${CANONICAL_SCAFFOLD_MARKER}
-import { AssetGuid } from '@forgeax/engine-pack/guid';
-import { buildMeshAttributeMapForUvSets } from '@forgeax/engine-geometry';
-import type { ScriptablePackDefinition } from '@forgeax/engine-pack/source';
-import type { Asset, AssetGuid as AssetGuidType } from '@forgeax/engine-types';
-import { ok } from '@forgeax/engine-types';
-
-const ${CANONICAL_MANIFEST_NAME} = ${data} as const;
-
-function parseGuid(value: string): AssetGuidType {
-  const parsed = AssetGuid.parse(value);
-  if (!parsed.ok) throw parsed.error;
-  return parsed.value;
-}
-
-function createOutput(kind: string): Asset {
-  switch (kind) {
-    case 'scene':
-      return { kind: 'scene', entities: [], mounts: [] };
-    case 'material':
-      return { kind: 'material', values: {} };
-    case 'mesh': {
-      const vertices = new Float32Array([
-        0, 0.7, 0, 0, 0, 1, 0.5, 1, 0, 0, 0, 1,
-        -0.7, -0.6, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1,
-        0.7, -0.6, 0, 0, 0, 1, 1, 0, 0, 0, 0, 1,
-      ]);
-      return {
-        kind: 'mesh',
-        vertices,
-        indices: new Uint16Array([0, 1, 2]),
-        attributes: { ...buildMeshAttributeMapForUvSets(1), position: vertices },
-        aabb: new Float32Array([-0.7, -0.6, 0, 0.7, 0.7, 0]),
-        submeshes: [{ indexOffset: 0, indexCount: 3, vertexCount: 3, topology: 'triangle-list', materialSlot: 0 }],
-        materialSlots: [{ slotName: 'Default' }],
-      };
-    }
-    default:
-      throw new Error(\`canonical ScriptablePack output kind is not mutable: \${kind}\`);
-  }
-}
-
-const assets = Object.fromEntries(
-  Object.entries(${CANONICAL_MANIFEST_NAME}.assets).map(([sourceKey, asset]) => [
-    sourceKey,
-    { ...asset, guid: parseGuid(asset.guid) },
-  ]),
-);
-const externalAssets = Object.fromEntries(
-  Object.entries(${CANONICAL_MANIFEST_NAME}.externalAssets).map(([alias, guid]) => [alias, parseGuid(guid)]),
-);
-
-export default {
-  schemaVersion: '1.0.0',
-  packageId: ${guidExpression(manifest.packageId)},
-  ${manifest.name === void 0 ? "" : `name: ${JSON.stringify(manifest.name)},
-  `}assets,
-  externalAssets,
-  build: () => ok(Object.fromEntries(Object.entries(assets).map(([sourceKey, asset]) => [sourceKey, createOutput(asset.kind)])) as Record<string, Asset>),
-} satisfies ScriptablePackDefinition;
-`;
-}
-function definitionFromCanonical(manifest) {
-  const packageId = AssetGuid.parse(manifest.packageId);
-  if (!packageId.ok) return invalidCanonicalGuid("$.packageId", manifest.packageId);
-  const assets = {};
-  for (const [sourceKey, output] of Object.entries(manifest.assets)) {
-    const guid = AssetGuid.parse(output.guid);
-    if (!guid.ok)
-      return invalidCanonicalGuid(`$.assets[${JSON.stringify(sourceKey)}].guid`, output.guid);
-    assets[sourceKey] = {
-      guid: guid.value,
-      kind: output.kind,
-      ...output.name === void 0 ? {} : { name: output.name }
-    };
-  }
-  const externalAssets = {};
-  for (const [alias, value] of Object.entries(manifest.externalAssets)) {
-    const guid = AssetGuid.parse(value);
-    if (!guid.ok) return invalidCanonicalGuid(`$.externalAssets[${JSON.stringify(alias)}]`, value);
-    externalAssets[alias] = guid.value;
-  }
-  return validateScriptablePackDefinition({
-    schemaVersion: "1.0.0",
-    packageId: packageId.value,
-    ...manifest.name === void 0 ? {} : { name: manifest.name },
-    assets,
-    externalAssets,
-    build: () => ok({})
-  });
-}
-function invalidCanonicalGuid(propertyPath, actual2) {
-  return err({
-    code: "pack-source-definition-invalid",
-    expected: "a canonical UUID string",
-    hint: "repair the canonical scaffold manifest GUID and inspect Meta again",
-    detail: { propertyPath, actual: actual2 }
-  });
-}
-function invalidCanonicalSource(sourcePath, error) {
-  return err({
-    code: "pack-source-definition-invalid",
-    expected: "a literal canonical-v1 manifest with the required package/assets/external fields",
-    hint: "repair the canonical scaffold or open it as custom source without structured mutation",
-    detail: {
-      sourcePath,
-      propertyPath: "$.canonicalManifest",
-      actual: error instanceof Error ? error.message : String(error)
-    }
-  });
-}
-async function atomicWrite(path, source) {
-  await mkdir(dirname(path), { recursive: true });
-  const temporary = `${path}.${process.pid}.${Date.now()}.tmp`;
-  try {
-    await writeFile(temporary, source, { encoding: "utf8", flag: "wx" });
-    await rename(temporary, path);
-  } catch (error) {
-    await rm(temporary, { force: true });
-    throw error;
-  }
-}
-function sameStrings(left, right) {
-  return [...left].sort().join("\0") === [...right].sort().join("\0");
-}
-function createFileSystemScriptablePackAuthoringPort(options) {
-  const resolvePath = (sourcePath) => confinedSourcePath(options.gameRoot, sourcePath);
-  async function readSource(sourcePath) {
-    const path = resolvePath(sourcePath);
-    if (!path.ok) return path;
-    try {
-      const source = await readFile(path.value.absolute, "utf8");
-      return ok({ ...path.value, source, revision: revisionOf(source) });
-    } catch (error) {
-      return err(
-        authoringError("pack-source-write-failed", {
-          expected: "a readable ScriptablePack source file",
-          actual: error instanceof Error ? error.message : String(error),
-          hint: "restore the source file or create it through the ScriptablePack gateway",
-          retryable: true,
-          recoveryActions: ["inspect-source-path", "retry"],
-          sourcePath
-        })
-      );
-    }
-  }
-  async function inspect(sourcePath) {
-    const read = await readSource(sourcePath);
-    if (!read.ok) return read;
-    let canonical;
-    try {
-      canonical = parseCanonicalManifest(read.value.source, read.value.relative);
-    } catch (error) {
-      return invalidCanonicalSource(read.value.relative, error);
-    }
-    const loaded = canonical === void 0 ? await loadScriptablePack(read.value.absolute, { metadataOnly: true }) : definitionFromCanonical(canonical);
-    if (!loaded.ok) return loaded;
-    return ok({
-      revision: read.value.revision,
-      meta: projectScriptablePackMeta(loaded.value, read.value.relative)
-    });
-  }
-  async function preflight(sourcePath) {
-    const read = await readSource(sourcePath);
-    if (!read.ok) return read;
-    const inspected = await inspect(sourcePath);
-    if (!inspected.ok) return inspected;
-    let canonical;
-    try {
-      canonical = parseCanonicalManifest(read.value.source, read.value.relative);
-    } catch (error) {
-      return invalidCanonicalSource(read.value.relative, error);
-    }
-    const incomingRefs = await options.incomingRefs?.(read.value.relative) ?? [];
-    return ok({
-      revision: inspected.value.revision,
-      meta: inspected.value.meta,
-      capabilities: canonical === void 0 ? {
-        inspect: true,
-        rebuild: true,
-        coldCook: true,
-        reason: "structured mutation is available only for canonical-v1 scaffolds"
-      } : {
-        inspect: true,
-        rebuild: true,
-        coldCook: true,
-        addOutput: true,
-        addExternalAsset: true,
-        renameDisplay: true,
-        removeOutput: true,
-        clone: true
-      },
-      incomingRefs
-    });
-  }
-  async function mutate(operation) {
-    const targetPath = operation.kind === "clone-scriptable-pack" ? operation.targetPath : operation.sourcePath;
-    const target = resolvePath(targetPath);
-    if (!target.ok) return target;
-    let manifest;
-    let currentRevision;
-    if (operation.kind === "create-scriptable-pack") {
-      if (!CANONICAL_MUTABLE_KINDS.has(operation.initialOutput.kind)) {
-        return err(
-          authoringError("pack-source-mutation-unsupported", {
-            expected: "a canonical scene, mesh, or material initial output",
-            actual: operation.initialOutput.kind,
-            hint: "create one of the canonical output kinds, then hand-author advanced outputs",
-            retryable: false,
-            recoveryActions: ["choose-supported-output-kind"],
-            requestId: operation.requestId,
-            sourcePath: operation.sourcePath
-          })
-        );
-      }
-      try {
-        await stat(target.value.absolute);
-        return err(
-          authoringError("pack-source-revision-conflict", {
-            expected: "an unused target source path",
-            actual: "source already exists",
-            hint: "inspect the existing source or choose a new path",
-            retryable: false,
-            recoveryActions: ["asset.preflight", "choose-new-source-path"],
-            requestId: operation.requestId,
-            sourcePath: operation.sourcePath
-          })
-        );
-      } catch {
-      }
-      manifest = {
-        schemaVersion: "1.0.0",
-        packageId: AssetGuid.format(operation.packageId),
-        ...operation.name === void 0 ? {} : { name: operation.name },
-        assets: {
-          [operation.initialOutput.sourceKey]: {
-            guid: AssetGuid.format(operation.initialOutput.guid),
-            kind: operation.initialOutput.kind,
-            ...operation.initialOutput.name === void 0 ? {} : { name: operation.initialOutput.name }
-          }
-        },
-        externalAssets: {}
-      };
-    } else {
-      const read = await readSource(operation.sourcePath);
-      if (!read.ok) return read;
-      currentRevision = read.value.revision;
-      if (operation.expectedRevision !== void 0 && operation.expectedRevision !== currentRevision) {
-        return err(
-          authoringError("pack-source-revision-conflict", {
-            expected: operation.expectedRevision,
-            actual: currentRevision,
-            hint: "inspect the current source revision, reconcile the edit, then retry with a new requestId",
-            retryable: true,
-            recoveryActions: ["asset.preflight", "mint-request-id"],
-            requestId: operation.requestId,
-            sourcePath: operation.sourcePath
-          })
-        );
-      }
-      let parsed;
-      try {
-        parsed = parseCanonicalManifest(read.value.source, read.value.relative);
-      } catch (error) {
-        return invalidCanonicalSource(read.value.relative, error);
-      }
-      if (parsed === void 0) {
-        return err(
-          authoringError("pack-source-mutation-unsupported", {
-            expected: "a canonical-v1 scaffold for structured source mutation",
-            actual: "custom ScriptablePack source",
-            hint: "clone into a canonical scaffold or edit custom source with a code editor",
-            retryable: false,
-            recoveryActions: ["clone-scriptable-pack", "open-code-editor"],
-            requestId: operation.requestId,
-            sourcePath: operation.sourcePath
-          })
-        );
-      }
-      manifest = parsed;
-    }
-    if (operation.kind === "clone-scriptable-pack") {
-      try {
-        await stat(target.value.absolute);
-        return err(
-          authoringError("pack-source-revision-conflict", {
-            expected: "an unused clone target source path",
-            actual: "source already exists",
-            hint: "inspect the existing target or choose a new path",
-            retryable: false,
-            recoveryActions: ["asset.preflight", "choose-new-source-path"],
-            requestId: operation.requestId,
-            sourcePath: target.value.relative
-          })
-        );
-      } catch {
-      }
-    }
-    if (operation.kind === "add-output") {
-      if (!CANONICAL_MUTABLE_KINDS.has(operation.assetKind)) {
-        return err(
-          authoringError("pack-source-mutation-unsupported", {
-            expected: "a canonical scene, mesh, or material output",
-            actual: operation.assetKind,
-            hint: "hand-author advanced output kinds in the source module",
-            retryable: false,
-            recoveryActions: ["open-code-editor"],
-            requestId: operation.requestId,
-            sourcePath: operation.sourcePath,
-            sourceKey: operation.sourceKey
-          })
-        );
-      }
-      manifest = {
-        ...manifest,
-        assets: {
-          ...manifest.assets,
-          [operation.sourceKey]: {
-            guid: AssetGuid.format(operation.guid),
-            kind: operation.assetKind,
-            ...operation.name === void 0 ? {} : { name: operation.name }
-          }
-        }
-      };
-    } else if (operation.kind === "add-external-asset") {
-      manifest = {
-        ...manifest,
-        externalAssets: {
-          ...manifest.externalAssets,
-          [operation.alias]: AssetGuid.format(operation.guid)
-        }
-      };
-    } else if (operation.kind === "rename-display") {
-      if (operation.target.kind === "package") manifest = { ...manifest, name: operation.name };
-      else {
-        const output = manifest.assets[operation.target.sourceKey];
-        if (output === void 0)
-          return err(
-            authoringError("pack-source-mutation-unsupported", {
-              expected: "an existing sourceKey",
-              actual: operation.target.sourceKey,
-              hint: "inspect Meta and choose a current output",
-              retryable: true,
-              recoveryActions: ["asset.preflight"],
-              requestId: operation.requestId,
-              sourcePath: operation.sourcePath,
-              sourceKey: operation.target.sourceKey
-            })
-          );
-        manifest = {
-          ...manifest,
-          assets: {
-            ...manifest.assets,
-            [operation.target.sourceKey]: { ...output, name: operation.name }
-          }
-        };
-      }
-    } else if (operation.kind === "remove-output") {
-      const incomingRefs = await options.incomingRefs?.(operation.sourcePath, operation.sourceKey) ?? [];
-      if (incomingRefs.length > 0 && !sameStrings(incomingRefs, operation.confirmIncomingRefs ?? [])) {
-        return err(
-          authoringError("pack-source-reference-conflict", {
-            expected: "explicit acknowledgement of every current incoming reference",
-            actual: `${incomingRefs.length} incoming references`,
-            hint: "inspect dependents, then confirm the exact incoming reference identities or cancel",
-            retryable: true,
-            recoveryActions: ["inspect-incoming-refs", "confirm-remove-output"],
-            requestId: operation.requestId,
-            sourcePath: operation.sourcePath,
-            sourceKey: operation.sourceKey,
-            incomingRefs
-          })
-        );
-      }
-      const { [operation.sourceKey]: removed, ...assets } = manifest.assets;
-      if (removed === void 0 || Object.keys(assets).length === 0) {
-        return err(
-          authoringError("pack-source-mutation-unsupported", {
-            expected: "an existing output while retaining at least one package output",
-            actual: operation.sourceKey,
-            hint: "keep one output or remove the entire source file through an explicit file operation",
-            retryable: false,
-            recoveryActions: ["asset.preflight"],
-            requestId: operation.requestId,
-            sourcePath: operation.sourcePath,
-            sourceKey: operation.sourceKey
-          })
-        );
-      }
-      manifest = { ...manifest, assets };
-    } else if (operation.kind === "clone-scriptable-pack") {
-      manifest = {
-        ...manifest,
-        packageId: AssetGuid.format(operation.packageId),
-        assets: Object.fromEntries(
-          Object.entries(manifest.assets).map(([sourceKey, output]) => [
-            sourceKey,
-            {
-              ...output,
-              guid: AssetGuid.format(operation.outputGuids[sourceKey])
-            }
-          ])
-        )
-      };
-    }
-    const source = renderCanonicalScriptablePack(manifest);
-    try {
-      await atomicWrite(target.value.absolute, source);
-      return ok({ sourcePath: target.value.relative, revision: revisionOf(source) });
-    } catch (error) {
-      return err(
-        authoringError("pack-source-write-failed", {
-          expected: "an atomic source-file replacement",
-          actual: error instanceof Error ? error.message : String(error),
-          hint: "repair filesystem permissions or disk capacity, then retry with a new requestId",
-          retryable: true,
-          recoveryActions: ["inspect-filesystem", "mint-request-id"],
-          requestId: operation.requestId,
-          sourcePath: target.value.relative
-        })
-      );
-    }
-  }
-  return {
-    preflight,
-    mutate,
-    inspect,
-    async rebuild(sourcePath, mode) {
-      const path = resolvePath(sourcePath);
-      if (!path.ok) return path;
-      const rebuilt = await options.rebuild?.(path.value.relative, mode) ?? ok(void 0);
-      return rebuilt.ok ? inspect(path.value.relative) : rebuilt;
-    }
-  };
-}
 
-export { createFileSystemScriptablePackAuthoringPort, createScriptablePackModuleExecutorPool, inventoryScriptablePackSource, loadScriptablePack, readOptionalBuildCache, renderCanonicalScriptablePack, scriptablePackDdcKey };
+export { createScriptablePackModuleExecutorPool, inventoryScriptablePackSource, loadScriptablePack, readOptionalBuildCache, scriptablePackDdcKey };
 //# sourceMappingURL=scriptable-pack-node.mjs.map
 //# sourceMappingURL=scriptable-pack-node.mjs.map