@forgeax/engine-pack 0.1.23 → 0.1.25

package/dist/build.mjs

@@ -1,4 +1,4 @@
-import { ok, err, catalogOperationsFor, authoringCapabilityForAssetKind, MATERIAL_TEXTURE_SLOTS, projectCookProductEvidence, projectAssetEvidence, validateSourceOverrideMap, PACK_ERROR_HINTS, catalogEntryDigest, AssetError, ImportError } from '@forgeax/engine-types';
+import { ok, err, catalogOperationsFor, authoringCapabilityForAssetKind, MATERIAL_TEXTURE_SLOTS, projectCookProductEvidence, projectAssetEvidence, validateSourceOverrideMap, PACK_ERROR_HINTS, catalogEntryDigest, deriveStandardLayerPlan, AssetError, ImportError } from '@forgeax/engine-types';
 import { dirname, resolve, isAbsolute, relative, join, basename, sep, extname } from 'path';
 import { sha1 } from '@noble/hashes/legacy.js';
 import { uuidv7obj } from 'uuidv7';
@@ -7461,10 +7461,10 @@ function definePack(definition) {
     validated.value
   );
 }
-function projectParameterizedPackMeta(definition, sourcePath) {
+function projectScriptablePackMeta(definition, sourcePath) {
   return {
     schemaVersion: "2.0.0",
-    kind: "parameterized-pack-source",
+    kind: "scriptable-pack-source",
     packageId: PackageId.format(definition.packageId),
     source: sourcePath,
     ..."parameters" in definition ? {
@@ -7561,7 +7561,7 @@ function validatePackDefinition(value, sourcePath) {
     })
   );
 }
-function isParameterizedPack(value) {
+function hasPackParameters(value) {
   return isRecord(value) && Array.isArray(value.parameters) && value.parameters.length > 0;
 }
 function resolvePackParameterValues(definition, overrides = {}, inheritedValues) {
@@ -7704,7 +7704,7 @@ function parsePackJsonAsset(value, sourceKey2) {
   };
   return ok(withArtifacts);
 }
-function parseParameterizedPackJson(value) {
+function parsePackSourceJson(value) {
   if (!isRecord(value))
     return jsonError("$", "a v3 pack.json object", value, "document is not an object");
   if (value.schemaVersion !== "3.0.0")
@@ -7783,10 +7783,8 @@ function parseParameterizedPackJson(value) {
     values: Object.freeze({ ...value.values })
   });
 }
-var parsePackJson = parseParameterizedPackJson;
-var parsePackAuthoringJson = parseParameterizedPackJson;
 function projectDirectPackJson(value) {
-  const parsed = "format" in value ? ok(value) : parseParameterizedPackJson(value);
+  const parsed = "format" in value ? ok(value) : parsePackSourceJson(value);
   if (!parsed.ok) return parsed;
   if (parsed.value.format !== "direct") {
     return failure(
@@ -7832,9 +7830,9 @@ async function resolvePackParameterInheritance(subject, readParent) {
     if (current.format === "direct") {
       return failure(
         authoringError(
-          "pack-parent-not-parameterized",
-          "a parameterized Pack source as the parent",
-          "direct packs cannot be instance parents; point the instance at a parameterized source",
+          "pack-parent-has-no-parameters",
+          "a ScriptablePack source with parameters as the parent",
+          "direct packs cannot be instance parents; point the instance at a ScriptablePack source with parameters",
           { packageId: currentId }
         )
       );
@@ -7845,7 +7843,7 @@ async function resolvePackParameterInheritance(subject, readParent) {
       if (descriptors2.value.length === 0) {
         return failure(
           authoringError(
-            "pack-parent-not-parameterized",
+            "pack-parent-has-no-parameters",
             "the parent source to declare a non-empty parameter list",
             "use clone for an independent zero-parameter Pack instead of creating an empty instance",
             { packageId: currentId }
@@ -7871,7 +7869,7 @@ async function resolvePackParameterInheritance(subject, readParent) {
         authoringError(
           "pack-parent-not-found",
           "the parent packageId to resolve in the source index",
-          "inspect the parent locator or recreate the instance from a live parameterized Pack",
+          "inspect the parent locator or recreate the instance from a live ScriptablePack with parameters",
           { packageId: currentId, parent: PackageId.format(current.parent) }
         )
       );
@@ -7913,7 +7911,7 @@ async function resolvePackParameterInheritance(subject, readParent) {
   return visit(subject, []);
 }
 var resolvePackInheritance = resolvePackParameterInheritance;
-var PARAMETERIZED_PACK_OPERATION_IDS = [
+var PACK_AUTHORING_OPERATION_IDS = [
   "asset.list",
   "asset.inspect",
   "asset.resolve",
@@ -7925,7 +7923,7 @@ var PARAMETERIZED_PACK_OPERATION_IDS = [
   "asset-source.rebuild",
   "asset-source.cold-cook"
 ];
-function createParameterizedPackAuthoringGateway(port) {
+function createPackAuthoringGateway(port) {
   const requests = /* @__PURE__ */ new Map();
   return {
     execute(operation) {
@@ -7991,14 +7989,12 @@ function createParameterizedPackAuthoringGateway(port) {
     }
   };
 }
-var PARAMETERIZED_PACK_OPERATION_DESCRIPTORS = PARAMETERIZED_PACK_OPERATION_IDS.map(
-  (id) => ({
-    id,
-    domain: id.startsWith("asset-source.") ? "session" : "asset",
-    readOnly: id.startsWith("asset."),
-    requiresRevision: !id.startsWith("asset.") && id !== "asset-source.create"
-  })
-);
+var PACK_AUTHORING_OPERATION_DESCRIPTORS = PACK_AUTHORING_OPERATION_IDS.map((id) => ({
+  id,
+  domain: id.startsWith("asset-source.") ? "session" : "asset",
+  readOnly: id.startsWith("asset."),
+  requiresRevision: !id.startsWith("asset.") && id !== "asset-source.create"
+}));
 
 // src/scriptable-pack.ts
 var SCRIPTABLE_PACK_ASSET_KINDS = [
@@ -8661,7 +8657,7 @@ var pack_schema_default = {
     },
     parent: {
       $ref: "#/$defs/guid36",
-      description: "Parent parameterized Pack packageId for one v3 instance."
+      description: "Parent ScriptablePack packageId for one v3 instance; the source may declare Pack parameters."
     },
     values: {
       type: "object",
@@ -9028,7 +9024,7 @@ function hydrateFailure(value) {
   return value;
 }
 var WorkerScriptablePackExecutor = class {
-  supportsParameterizedContext = true;
+  supportsPackParameters = true;
   worker;
   compileRoot;
   nextBuildId = 0;
@@ -9129,7 +9125,7 @@ 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 parameterizedLoadFailure(sourcePath, reason, phase, diagnostic, timeoutMs) {
+function scriptablePackLoadFailure(sourcePath, reason, phase, diagnostic, timeoutMs) {
   return {
     code: "pack-parameter-invalid",
     expected: "a trusted Pack v2 authoring module with a valid default export",
@@ -9143,14 +9139,14 @@ function parameterizedLoadFailure(sourcePath, reason, phase, diagnostic, timeout
     }
   };
 }
-async function loadParameterizedScriptablePack(sourcePath, options = {}) {
+async function loadScriptablePack(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("parameterized-pack-module-timeout");
+    const timeoutSignal = /* @__PURE__ */ Symbol("scriptable-pack-module-timeout");
     const loaded = await Promise.race([
       executor.load(sourcePath),
       new Promise((resolve4) => {
@@ -9160,7 +9156,7 @@ async function loadParameterizedScriptablePack(sourcePath, options = {}) {
     if (loaded === timeoutSignal) {
       disposeReason = "timeout";
       return err(
-        parameterizedLoadFailure(
+        scriptablePackLoadFailure(
           sourcePath,
           "timeout",
           "module-load",
@@ -9187,7 +9183,7 @@ async function loadParameterizedScriptablePack(sourcePath, options = {}) {
         let buildTimedOut = false;
         let buildTimeout;
         const timeoutResult = err(
-          parameterizedLoadFailure(
+          scriptablePackLoadFailure(
             sourcePath,
             "timeout",
             "build",
@@ -9196,7 +9192,7 @@ async function loadParameterizedScriptablePack(sourcePath, options = {}) {
           )
         );
         try {
-          const invocation = "supportsParameterizedContext" in executor && executor.supportsParameterizedContext === true ? build(context.readByGuid, {
+          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);
@@ -9226,7 +9222,7 @@ async function loadParameterizedScriptablePack(sourcePath, options = {}) {
   } catch (error) {
     disposeReason = "failure";
     return err(
-      parameterizedLoadFailure(
+      scriptablePackLoadFailure(
         sourcePath,
         "module-load",
         "module-load",
@@ -9249,9 +9245,13 @@ function packErr(error) {
 function record(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
-var STANDARD_SCRIPTABLE_PACK_SCAN_OPTIONS = Object.freeze(
-  {}
-);
+var STANDARD_SCRIPTABLE_PACK_SCAN_OPTIONS = Object.freeze({
+  // Scriptable Packs execute in an isolated worker.  A cold worker must
+  // compile the authored source closure before it can return metadata;
+  // heavy procedural packs otherwise make the shared catalog fall back to
+  // an empty degraded projection at the old 15-second budget.
+  timeoutMs: 6e4
+});
 var BLACKLIST = /* @__PURE__ */ new Set([
   "node_modules",
   "__tests__",
@@ -9379,7 +9379,7 @@ async function scanValidated(roots, opts = {}, capture) {
     if (!loaded.ok) return loaded;
     const { raw, parsed } = loaded.value;
     if (record(parsed) && parsed.schemaVersion === "3.0.0") {
-      const authoring = parseParameterizedPackJson(parsed);
+      const authoring = parsePackSourceJson(parsed);
       if (!authoring.ok) {
         return packErr(
           makePackError("pack-malformed-pack", {
@@ -9623,7 +9623,7 @@ async function scanValidated(roots, opts = {}, capture) {
       ...opts.scriptablePack ?? {},
       ...capture === void 0 ? { metadataOnly: true } : {}
     };
-    const loaded = await loadParameterizedScriptablePack(sourcePath, loaderOptions);
+    const loaded = await loadScriptablePack(sourcePath, loaderOptions);
     if (!loaded.ok) {
       const diagnostic = loaded.error.detail.diagnostic;
       return packErr(
@@ -9652,12 +9652,12 @@ async function scanValidated(roots, opts = {}, capture) {
     const packageCollision = registerPackage(
       PackageId.format(loaded.value.packageId),
       sourcePath,
-      "parameterized"
+      "scriptable"
     );
     if (packageCollision !== void 0) return packErr(packageCollision);
-    const meta = projectParameterizedPackMeta(loaded.value, sourcePath);
+    const meta = projectScriptablePackMeta(loaded.value, sourcePath);
     capture?.declarations.set(sourcePath, {
-      format: "pack.ts-parameterized",
+      format: "pack.ts",
       sourcePath,
       sourceRevision: `sha256:${createHash("sha256").update(source).digest("hex")}`,
       value: meta,
@@ -9686,15 +9686,15 @@ async function scanValidated(roots, opts = {}, capture) {
       );
     }
     const kind = packageKind.get(parentId);
-    if (kind !== "parameterized" && kind !== "instance") {
+    if (kind !== "scriptable" && kind !== "instance") {
       return packErr(
         makePackError("pack-malformed-pack", {
           path: instance.path,
-          reason: "pack-parent-not-parameterized",
+          reason: "pack-parent-has-no-parameters",
           ajvErrors: [
             {
               instancePath: "/parent",
-              message: `parent ${instance.parent} is not a parameterized Pack`
+              message: `parent ${instance.parent} is not a ScriptablePack source with parameters`
             }
           ]
         })
@@ -9764,7 +9764,7 @@ async function scanInventory(roots, opts = {}) {
     const declaration = declarations.get(sourcePath);
     if (declaration?.format !== "pack.json") continue;
     if (declaration.value.schemaVersion === "3.0.0") {
-      const parsed = parseParameterizedPackJson(declaration.value);
+      const parsed = parsePackSourceJson(declaration.value);
       if (!parsed.ok) {
         return packErr(
           makePackError("pack-malformed-pack", {
@@ -9886,7 +9886,7 @@ function projectMeta(rawPath, cwd, base, importerPolicy, sourceDeclaration, sour
   };
 }
 function projectSource(path, cwd, base, importerPolicy, visibility, sourceDeclaration, declarations, sourceIdentityFor) {
-  if (sourceDeclaration.format === "pack.ts-parameterized") {
+  if (sourceDeclaration.format === "pack.ts") {
     return { entries: [] };
   }
   if (sourceDeclaration.format === "meta.json") {
@@ -9912,7 +9912,7 @@ function projectSource(path, cwd, base, importerPolicy, visibility, sourceDeclar
   const parsed = sourceDeclaration.value;
   const sourcePath = catalogSourcePathFor(cwd, path, sourceIdentityFor);
   if (parsed.schemaVersion === "3.0.0") {
-    const authoring = parseParameterizedPackJson(parsed);
+    const authoring = parsePackSourceJson(parsed);
     if (!authoring.ok) {
       return {
         entries: [],
@@ -10295,6 +10295,25 @@ function calculateCatalogDelta(previous, next, revision) {
     revisions: revision
   };
 }
+var STANDARD_ROOT_MODULES = /* @__PURE__ */ new Set([
+  "forgeax::default-standard-pbr",
+  "forgeax::pbr-skin",
+  "forgeax_material::standard",
+  "forgeax_material::pbr-skin",
+  "forgeax::default-shadow-caster"
+]);
+function isStandardRootModule(module) {
+  return STANDARD_ROOT_MODULES.has(module);
+}
+function isStandardMaterialRecord(record2) {
+  return record2.resolved.passes.some((pass) => isStandardRootModule(pass.program.module));
+}
+function materialLayerPlanIdentity(record2) {
+  if (!isStandardMaterialRecord(record2)) {
+    return void 0;
+  }
+  return deriveStandardLayerPlan(record2.resolved.parameters, record2.resolved.passes).identity;
+}
 function unique(values) {
   return [...new Set(values)].sort();
 }
@@ -10369,6 +10388,14 @@ function invalid(field, actual) {
     }
   });
 }
+function normalizeArtifactBytes(value) {
+  if (Array.isArray(value)) {
+    return value.every((byte) => Number.isInteger(byte) && byte >= 0 && byte <= 255) ? Uint8Array.from(value) : void 0;
+  }
+  if (!ArrayBuffer.isView(value)) return void 0;
+  const view = value;
+  return new Uint8Array(view.buffer, view.byteOffset, view.byteLength).slice();
+}
 var IDENTITY_FIELDS = [
   "materialContractDigest",
   "sourceRevision",
@@ -10425,6 +10452,12 @@ function validateMaterialCookReceipt(value, expected = {}) {
   if (derivedInterface.layoutIdentity !== identity.layoutIdentity) {
     return invalid("receipt.derivedInterface.layoutIdentity", derivedInterface.layoutIdentity);
   }
+  if (derivedInterface.layerPlanIdentity !== void 0 && (typeof derivedInterface.layerPlanIdentity !== "string" || derivedInterface.layerPlanIdentity.length === 0)) {
+    return invalid(
+      "receipt.derivedInterface.layerPlanIdentity",
+      derivedInterface.layerPlanIdentity
+    );
+  }
   for (const field of ["sourceClosure", "profile", "compilerVersion"]) {
     const fieldValue = candidate[field];
     if (field === "sourceClosure" && !Array.isArray(fieldValue) || field !== "sourceClosure" && typeof fieldValue !== "string") {
@@ -10450,7 +10483,10 @@ function validateMaterialCookReceipt(value, expected = {}) {
     profile: candidate.profile,
     compilerVersion: candidate.compilerVersion,
     identity,
-    derivedInterface: { layoutIdentity: derivedInterface.layoutIdentity }
+    derivedInterface: {
+      layoutIdentity: derivedInterface.layoutIdentity,
+      ...derivedInterface.layerPlanIdentity === void 0 ? {} : { layerPlanIdentity: derivedInterface.layerPlanIdentity }
+    }
   });
 }
 function validateCookedMaterialRecord(value) {
@@ -10465,6 +10501,33 @@ function validateCookedMaterialRecord(value) {
     return invalid("publicationGeneration", candidate.publicationGeneration);
   if (candidate.specializationKey !== void 0 && typeof candidate.specializationKey !== "string")
     return invalid("specializationKey");
+  if (candidate.variantContext !== void 0) {
+    if (candidate.variantContext === null || typeof candidate.variantContext !== "object")
+      return invalid("variantContext");
+    const context = candidate.variantContext;
+    if (context.backend !== "webgpu" && context.backend !== "webgl2" && context.backend !== "wgpu-native" || context.capability !== "storage-buffer" && context.capability !== "uniform-fallback")
+      return invalid("variantContext", candidate.variantContext);
+  }
+  if (candidate.variants !== void 0) {
+    if (!Array.isArray(candidate.variants)) return invalid("variants");
+    for (const [index, value2] of candidate.variants.entries()) {
+      if (value2 === null || typeof value2 !== "object") return invalid(`variants[${index}]`);
+      const variant = value2;
+      const context = variant.context;
+      if (context === null || typeof context !== "object")
+        return invalid(`variants[${index}].context`);
+      const contextRecord = context;
+      if (contextRecord.backend !== "webgpu" && contextRecord.backend !== "webgl2" && contextRecord.backend !== "wgpu-native" || contextRecord.capability !== "storage-buffer" && contextRecord.capability !== "uniform-fallback")
+        return invalid(`variants[${index}].context`, context);
+      if (typeof variant.specializationKey !== "string" || variant.specializationKey.length === 0)
+        return invalid(`variants[${index}].specializationKey`);
+      if (variant.artifact === null || typeof variant.artifact !== "object")
+        return invalid(`variants[${index}].artifact`);
+      const variantArtifact = variant.artifact;
+      if (typeof variantArtifact.mediaType !== "string" || typeof variantArtifact.path !== "string" || typeof variantArtifact.digest !== "string" || normalizeArtifactBytes(variantArtifact.bytes) === void 0)
+        return invalid(`variants[${index}].artifact`);
+    }
+  }
   if (candidate.artifactDigest !== void 0 && typeof candidate.artifactDigest !== "string")
     return invalid("artifactDigest");
   if (candidate.sourceClosure !== void 0 && (!Array.isArray(candidate.sourceClosure) || candidate.sourceClosure.some((path) => typeof path !== "string")))
@@ -10493,6 +10556,26 @@ function validateCookedMaterialRecord(value) {
     artifactDigest: artifact.digest
   });
   if (!receiptResult.ok) return receiptResult;
+  const resolved = candidate.resolved;
+  if (!Array.isArray(resolved.passes)) return invalid("resolved.passes", resolved.passes);
+  if (!Array.isArray(resolved.parameters))
+    return invalid("resolved.parameters", resolved.parameters);
+  if (resolved.values === null || typeof resolved.values !== "object" || Array.isArray(resolved.values))
+    return invalid("resolved.values", resolved.values);
+  let expectedLayerPlanIdentity;
+  try {
+    expectedLayerPlanIdentity = materialLayerPlanIdentity({
+      resolved
+    });
+  } catch (error) {
+    return invalid("resolved.layerPlanIdentity", error instanceof Error ? error.message : error);
+  }
+  if (expectedLayerPlanIdentity !== void 0 && receiptResult.value.derivedInterface.layerPlanIdentity !== expectedLayerPlanIdentity) {
+    return invalid(
+      "receipt.derivedInterface.layerPlanIdentity",
+      receiptResult.value.derivedInterface.layerPlanIdentity
+    );
+  }
   if (candidate.artifactDigest !== void 0 && candidate.artifactDigest !== artifact.digest)
     return invalid("artifactDigest", candidate.artifactDigest);
   if (candidate.publicationGeneration !== void 0 && receiptResult.value.identity.cookGeneration !== candidate.publicationGeneration)
@@ -10501,8 +10584,21 @@ function validateCookedMaterialRecord(value) {
     ...candidate,
     artifact: {
       ...artifact,
-      bytes: ArrayBuffer.isView(artifact.bytes) ? Uint8Array.from(artifact.bytes) : Uint8Array.from(artifact.bytes)
+      bytes: normalizeArtifactBytes(artifact.bytes)
     },
+    ...Array.isArray(candidate.variants) ? {
+      variants: candidate.variants.map((value2) => {
+        const variant = value2;
+        const variantArtifact = variant.artifact;
+        return {
+          ...variant,
+          artifact: {
+            ...variantArtifact,
+            bytes: normalizeArtifactBytes(variantArtifact.bytes)
+          }
+        };
+      })
+    } : {},
     receipt: receiptResult.value
   };
   return ok(normalized);
@@ -10512,6 +10608,8 @@ function projectCookedMaterialRecord(record2) {
     resolved: record2.resolved,
     refs: record2.refs,
     artifact: record2.artifact,
+    ...record2.variantContext === void 0 ? {} : { variantContext: record2.variantContext },
+    ...record2.variants === void 0 ? {} : { variants: record2.variants },
     receipt: record2.receipt,
     schemaVersion: record2.schemaVersion
   };
@@ -10786,230 +10884,6 @@ function decodeMeshBinHeader(bytes, sourceKey2 = "<unknown mesh source>") {
     }
   };
 }
-function failure4(code, expected, hint, detail) {
-  return { ok: false, error: { code, expected, hint, detail } };
-}
-function sorted(value) {
-  if (value instanceof Uint8Array) return Buffer.from(value).toString("base64");
-  if (Array.isArray(value)) return value.map(sorted);
-  if (value !== null && typeof value === "object") {
-    const output = {};
-    for (const key of Object.keys(value).sort()) {
-      output[key] = sorted(value[key]);
-    }
-    return output;
-  }
-  return value;
-}
-function packageUrl(base, packagePath) {
-  const prefix = base === "/" ? "" : `/${base.replace(/^\/+|\/+$/g, "")}`;
-  return `${prefix}/${packagePath.replace(/^\/+/, "")}`;
-}
-function safePath(path) {
-  const normalized = path.replaceAll("\\", "/");
-  return normalized.length > 0 && !normalized.startsWith("/") && !/^[A-Za-z]:\//.test(normalized) && !normalized.split("/").includes("..");
-}
-function digest(assets) {
-  const pack = { schemaVersion: "2.0.0", kind: "internal-text-package", assets };
-  const hash = createHash("sha256").update(
-    JSON.stringify(
-      sorted({
-        ...pack,
-        assets: pack.assets.map((asset) => ({
-          ...asset,
-          artifacts: Object.fromEntries(
-            Object.entries(asset.artifacts).map(([key, artifact]) => [
-              key,
-              {
-                mediaType: artifact.mediaType,
-                ...artifact.assetCodec === void 0 ? {} : { assetCodec: artifact.assetCodec },
-                byteLength: artifact.bytes.byteLength
-              }
-            ])
-          )
-        }))
-      })
-    )
-  );
-  for (const [key, artifact] of assets.flatMap(
-    (asset) => Object.entries(asset.artifacts).map(
-      ([localKey, body]) => [`${asset.guid}/${localKey}`, body]
-    )
-  ).sort(([left], [right]) => left.localeCompare(right))) {
-    hash.update(key).update(artifact.bytes);
-  }
-  return `sha256:${hash.digest("hex")}`;
-}
-function packageDocument(assets, artifactPath) {
-  return {
-    schemaVersion: "2.0.0",
-    kind: "internal-text-package",
-    assets: assets.map((asset) => ({
-      guid: asset.guid,
-      kind: asset.kind,
-      ...asset.name === void 0 ? {} : { name: asset.name },
-      payload: asset.payload,
-      refs: asset.refs,
-      artifacts: Object.fromEntries(
-        Object.entries(asset.artifacts).map(([key, artifact]) => [
-          key,
-          {
-            path: artifactPath(asset.guid, key),
-            mediaType: artifact.mediaType,
-            ...artifact.assetCodec === void 0 ? {} : { assetCodec: artifact.assetCodec },
-            contentEncoding: "identity",
-            byteLength: artifact.bytes.byteLength,
-            integrity: {
-              algorithm: "sha256",
-              digest: `sha256:${createHash("sha256").update(artifact.bytes).digest("hex")}`
-            }
-          }
-        ])
-      )
-    }))
-  };
-}
-function transportArtifacts(assets, artifactPath) {
-  return assets.flatMap(
-    (asset) => Object.entries(asset.artifacts).flatMap(([localKey, artifact]) => [
-      {
-        guid: asset.guid,
-        localKey,
-        path: artifactPath(asset.guid, localKey),
-        mediaType: artifact.mediaType,
-        ...artifact.assetCodec === void 0 ? {} : { assetCodec: artifact.assetCodec },
-        bytes: artifact.bytes
-      }
-    ])
-  );
-}
-async function finalizePackageProduct(product, policy) {
-  if (product.sourceRevision.trim().length === 0) {
-    return failure4(
-      "missing-source-revision",
-      "a non-empty source revision",
-      "rebuild the inventory and provide the producer source revision",
-      {}
-    );
-  }
-  const seen = /* @__PURE__ */ new Set();
-  for (const asset of product.assets) {
-    const guid = asset.guid.toLowerCase();
-    if (seen.has(guid)) {
-      return failure4(
-        "duplicate-guid",
-        "one terminal product row per GUID",
-        "repair the inventory or producer output before finalization",
-        { guid }
-      );
-    }
-    seen.add(guid);
-    for (const [key, artifact] of Object.entries(asset.artifacts)) {
-      if (!safePath(key) || !(artifact.bytes instanceof Uint8Array)) {
-        return failure4(
-          "invalid-artifact",
-          "asset-local artifact keys and byte bodies",
-          "repair the producer artifact before finalization",
-          { guid, key }
-        );
-      }
-    }
-  }
-  for (const guid of seen) {
-    if (!product.receipts.some((receipt) => receipt.guid.toLowerCase() === guid)) {
-      return failure4(
-        "missing-receipt",
-        "one receipt for every terminal product GUID",
-        "preserve the producer receipt when handing the product to engine-pack",
-        { guid }
-      );
-    }
-  }
-  const assets = [...product.assets].sort((left, right) => left.guid.localeCompare(right.guid));
-  const document = packageDocument(assets, policy.artifactPath);
-  const packageBytes = new TextEncoder().encode(JSON.stringify(sorted(document)));
-  if (policy.sink !== void 0) {
-    for (const asset of assets) {
-      for (const [key, artifact] of Object.entries(asset.artifacts)) {
-        const path = policy.artifactPath(asset.guid, key);
-        if (!safePath(path)) {
-          return failure4(
-            "invalid-artifact",
-            "package-relative artifact output paths",
-            "repair the finalizer artifact path policy",
-            { guid: asset.guid, key }
-          );
-        }
-        await policy.sink(path, artifact.bytes);
-      }
-    }
-    if (!safePath(policy.packagePath)) {
-      return failure4(
-        "invalid-artifact",
-        "a package-relative package path",
-        "repair the finalizer package path policy",
-        { key: policy.packagePath }
-      );
-    }
-    await policy.sink(policy.packagePath, packageBytes);
-  }
-  return {
-    ok: true,
-    value: {
-      pack: document,
-      packageUrl: packageUrl(policy.base, policy.packagePath),
-      digest: digest(product.assets),
-      receipts: product.receipts,
-      diagnostics: product.diagnostics,
-      sourceRevision: product.sourceRevision,
-      ...product.sourceKey === void 0 ? {} : { sourceKey: product.sourceKey }
-    }
-  };
-}
-async function finalizePackageTransportSource(input, policy) {
-  const sourceRevision = packageTransportRevision(input);
-  const product = {
-    assets: input.assets,
-    receipts: input.receipts ?? input.assets.map((asset) => ({
-      guid: asset.guid,
-      origin: "sourceMeta",
-      status: "succeeded",
-      inputFingerprint: sourceRevision
-    })),
-    diagnostics: input.diagnostics ?? [],
-    sourceRevision,
-    ...input.sourceKey === void 0 ? {} : { sourceKey: input.sourceKey }
-  };
-  const finalized = await finalizePackageProduct(product, policy);
-  if (!finalized.ok) throw finalized.error;
-  return {
-    pack: finalized.value.pack,
-    packageUrl: finalized.value.packageUrl,
-    artifacts: transportArtifacts(product.assets, policy.artifactPath),
-    digest: finalized.value.digest,
-    receipts: finalized.value.receipts,
-    sourceRevision,
-    semantic: JSON.stringify(sorted(finalized.value.pack))
-  };
-}
-function revisionStable(value) {
-  if (value instanceof Uint8Array) {
-    return {
-      byteLength: value.byteLength,
-      digest: createHash("sha256").update(value).digest("hex")
-    };
-  }
-  if (Array.isArray(value)) return value.map(revisionStable);
-  if (value !== null && typeof value === "object") {
-    return Object.fromEntries(
-      Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, item]) => [key, revisionStable(item)])
-    );
-  }
-  return value;
-}
-function packageTransportRevision(value) {
-  return createHash("sha256").update(JSON.stringify(revisionStable(value))).digest("hex");
-}
 function isRecord3(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
@@ -11141,7 +11015,7 @@ function scanFailure(operation, cause) {
   const value = cause !== null && typeof cause === "object" ? cause : {};
   const detail = value.detail !== null && typeof value.detail === "object" ? value.detail : {};
   const reason = isRecord3(detail) && typeof detail.reason === "string" ? detail.reason : void 0;
-  const code = reason === "pack-parent-not-found" || reason === "pack-parent-cycle" || reason === "pack-parent-not-parameterized" ? reason : value.code === "pack-guid-collision" ? "pack-guid-collision" : "pack-parameter-invalid";
+  const code = reason === "pack-parent-not-found" || reason === "pack-parent-cycle" || reason === "pack-parent-has-no-parameters" ? reason : value.code === "pack-guid-collision" ? "pack-guid-collision" : "pack-parameter-invalid";
   return makeError(
     code,
     typeof value.expected === "string" ? value.expected : "a valid Pack Source Index",
@@ -11313,7 +11187,7 @@ async function createSnapshot(options, operation) {
   const directAssets = [];
   for (const [sourcePath, declaration] of scanned.value.declarations) {
     const relativePath = relative(resolve(options.gameRoot), sourcePath).split(sep).join("/");
-    if (declaration.format === "pack.ts-parameterized") {
+    if (declaration.format === "pack.ts") {
       subjects.set(packageKey(declaration.definition.packageId), {
         format: "source",
         packageId: declaration.definition.packageId,
@@ -11324,7 +11198,7 @@ async function createSnapshot(options, operation) {
       continue;
     }
     if (declaration.format !== "pack.json" || declaration.value.schemaVersion !== "3.0.0") continue;
-    const parsed = parseParameterizedPackJson(declaration.value);
+    const parsed = parsePackSourceJson(declaration.value);
     if (!parsed.ok) return err(parsed.error);
     if (parsed.value.format === "direct") {
       const projected = projectDirectPackJson(parsed.value);
@@ -12037,7 +11911,7 @@ function revisionConflict(operation, path, actual) {
 function directJson(packageId2, assets) {
   return { schemaVersion: "3.0.0", packageId: PackageId.format(packageId2), assets };
 }
-function parameterizedScaffold(packageId2, parameters) {
+function packSourceScaffold(packageId2, parameters) {
   const parameterSource = parameters === void 0 ? "" : "\n  parameters: " + JSON.stringify(
     parameters.map((parameter) => jsonValue2(parameter)),
     null,
@@ -12125,13 +11999,13 @@ async function executeRaw(options, operation) {
           makeError(
             "pack-parameter-invalid",
             "direct create to contain assets only",
-            "use pack.ts for a parameterized source or create-instance for parent+values",
+            "use pack.ts for a ScriptablePack source or create-instance for parent+values",
             { requestId: operation.requestId }
           )
         );
       }
       const assets = operation.initialAssets ?? {};
-      const parsed = parseParameterizedPackJson(directJson(identity.value, assets));
+      const parsed = parsePackSourceJson(directJson(identity.value, assets));
       if (!parsed.ok) return err(parsed.error);
       if (parsed.value.format !== "direct") {
         return err(
@@ -12187,7 +12061,7 @@ async function executeRaw(options, operation) {
         }
         parameters = validated.value.parameters;
       }
-      source = parameterizedScaffold(identity.value, parameters);
+      source = packSourceScaffold(identity.value, parameters);
       const serialized = parameters === void 0 ? void 0 : serializedParameters({
         schemaVersion: "2.0.0",
         packageId: identity.value,
@@ -12283,7 +12157,7 @@ async function executeRaw(options, operation) {
           )
         );
       }
-      const parsed = parseParameterizedPackJson(parsedValue);
+      const parsed = parsePackSourceJson(parsedValue);
       if (!parsed.ok) return err(parsed.error);
       source = `${JSON.stringify(
         parsed.value.format === "direct" ? directJson(identity.value, parsed.value.assets) : {
@@ -12343,7 +12217,7 @@ async function executeRaw(options, operation) {
         makeError(
           "pack-parent-not-found",
           "a parent packageId for the new instance",
-          "pass parentPackageId or parent and point it at a parameterized source",
+          "pass parentPackageId or parent and point it at a ScriptablePack source with parameters",
           { requestId: operation.requestId }
         )
       );
@@ -12366,7 +12240,7 @@ async function executeRaw(options, operation) {
         makeError(
           "pack-parent-not-found",
           "the parent packageId to exist in the current Source Index",
-          "inspect the Source Index and choose a parameterized parent",
+          "inspect the Source Index and choose a ScriptablePack parent with parameters",
           { requestId: operation.requestId, parent: parentText }
         )
       );
@@ -12374,8 +12248,8 @@ async function executeRaw(options, operation) {
     if (parent.format === "source" && !("parameters" in parent.definition)) {
       return err(
         makeError(
-          "pack-parent-not-parameterized",
-          "a non-empty parameterized Pack source as the parent",
+          "pack-parent-has-no-parameters",
+          "a ScriptablePack source with a non-empty parameter list as the parent",
           "use asset-source.clone for a zero-parameter Pack",
           { requestId: operation.requestId, parent: parentText }
         )
@@ -12384,8 +12258,8 @@ async function executeRaw(options, operation) {
     if (parent.format === "direct") {
       return err(
         makeError(
-          "pack-parent-not-parameterized",
-          "a parameterized Pack source or instance as the parent",
+          "pack-parent-has-no-parameters",
+          "a ScriptablePack source or instance with parameters as the parent",
           "direct Packs cannot be instance parents",
           { requestId: operation.requestId, parent: parentText }
         )
@@ -12488,7 +12362,7 @@ async function executeRaw(options, operation) {
         )
       );
     }
-    const parsed = parseParameterizedPackJson(json);
+    const parsed = parsePackSourceJson(json);
     if (!parsed.ok) return err(parsed.error);
     if (parsed.value.format !== "instance") {
       return err(
@@ -12591,20 +12465,242 @@ async function executeRaw(options, operation) {
   return err(
     makeError(
       "pack-parameter-invalid",
-      "a supported parameterized Pack operation",
-      "use one of PARAMETERIZED_PACK_OPERATION_IDS",
+      "a supported Pack authoring operation",
+      "use one of PACK_AUTHORING_OPERATION_IDS",
       { requestId: operation.requestId, operation: operation.operation }
     )
   );
 }
-function createFileSystemParameterizedPackAuthoringPort(options) {
+function createFileSystemPackAuthoringPort(options) {
   return { execute: (operation) => executeRaw(options, operation) };
 }
-function createFileSystemParameterizedPackAuthoringGateway(options) {
-  return createParameterizedPackAuthoringGateway(
-    createFileSystemParameterizedPackAuthoringPort(options)
+function createFileSystemPackAuthoringGateway(options) {
+  return createPackAuthoringGateway(createFileSystemPackAuthoringPort(options));
+}
+function failure4(code, expected, hint, detail) {
+  return { ok: false, error: { code, expected, hint, detail } };
+}
+function sorted(value) {
+  if (value instanceof Uint8Array) return Buffer.from(value).toString("base64");
+  if (Array.isArray(value)) return value.map(sorted);
+  if (value !== null && typeof value === "object") {
+    const output = {};
+    for (const key of Object.keys(value).sort()) {
+      output[key] = sorted(value[key]);
+    }
+    return output;
+  }
+  return value;
+}
+function packageUrl(base, packagePath) {
+  const prefix = base === "/" ? "" : `/${base.replace(/^\/+|\/+$/g, "")}`;
+  return `${prefix}/${packagePath.replace(/^\/+/, "")}`;
+}
+function safePath(path) {
+  const normalized = path.replaceAll("\\", "/");
+  return normalized.length > 0 && !normalized.startsWith("/") && !/^[A-Za-z]:\//.test(normalized) && !normalized.split("/").includes("..");
+}
+function digest(assets) {
+  const pack = { schemaVersion: "2.0.0", kind: "internal-text-package", assets };
+  const hash = createHash("sha256").update(
+    JSON.stringify(
+      sorted({
+        ...pack,
+        assets: pack.assets.map((asset) => ({
+          ...asset,
+          artifacts: Object.fromEntries(
+            Object.entries(asset.artifacts).map(([key, artifact]) => [
+              key,
+              {
+                mediaType: artifact.mediaType,
+                ...artifact.assetCodec === void 0 ? {} : { assetCodec: artifact.assetCodec },
+                byteLength: artifact.bytes.byteLength
+              }
+            ])
+          )
+        }))
+      })
+    )
+  );
+  for (const [key, artifact] of assets.flatMap(
+    (asset) => Object.entries(asset.artifacts).map(
+      ([localKey, body]) => [`${asset.guid}/${localKey}`, body]
+    )
+  ).sort(([left], [right]) => left.localeCompare(right))) {
+    hash.update(key).update(artifact.bytes);
+  }
+  return `sha256:${hash.digest("hex")}`;
+}
+function packageDocument(assets, artifactPath) {
+  return {
+    schemaVersion: "2.0.0",
+    kind: "internal-text-package",
+    assets: assets.map((asset) => ({
+      guid: asset.guid,
+      kind: asset.kind,
+      ...asset.name === void 0 ? {} : { name: asset.name },
+      payload: asset.payload,
+      refs: asset.refs,
+      artifacts: Object.fromEntries(
+        Object.entries(asset.artifacts).map(([key, artifact]) => [
+          key,
+          {
+            path: artifactPath(asset.guid, key),
+            mediaType: artifact.mediaType,
+            ...artifact.assetCodec === void 0 ? {} : { assetCodec: artifact.assetCodec },
+            contentEncoding: "identity",
+            byteLength: artifact.bytes.byteLength,
+            integrity: {
+              algorithm: "sha256",
+              digest: `sha256:${createHash("sha256").update(artifact.bytes).digest("hex")}`
+            }
+          }
+        ])
+      )
+    }))
+  };
+}
+function transportArtifacts(assets, artifactPath) {
+  return assets.flatMap(
+    (asset) => Object.entries(asset.artifacts).flatMap(([localKey, artifact]) => [
+      {
+        guid: asset.guid,
+        localKey,
+        path: artifactPath(asset.guid, localKey),
+        mediaType: artifact.mediaType,
+        ...artifact.assetCodec === void 0 ? {} : { assetCodec: artifact.assetCodec },
+        bytes: artifact.bytes
+      }
+    ])
   );
 }
+async function finalizePackageProduct(product, policy) {
+  if (product.sourceRevision.trim().length === 0) {
+    return failure4(
+      "missing-source-revision",
+      "a non-empty source revision",
+      "rebuild the inventory and provide the producer source revision",
+      {}
+    );
+  }
+  const seen = /* @__PURE__ */ new Set();
+  for (const asset of product.assets) {
+    const guid = asset.guid.toLowerCase();
+    if (seen.has(guid)) {
+      return failure4(
+        "duplicate-guid",
+        "one terminal product row per GUID",
+        "repair the inventory or producer output before finalization",
+        { guid }
+      );
+    }
+    seen.add(guid);
+    for (const [key, artifact] of Object.entries(asset.artifacts)) {
+      if (!safePath(key) || !(artifact.bytes instanceof Uint8Array)) {
+        return failure4(
+          "invalid-artifact",
+          "asset-local artifact keys and byte bodies",
+          "repair the producer artifact before finalization",
+          { guid, key }
+        );
+      }
+    }
+  }
+  for (const guid of seen) {
+    if (!product.receipts.some((receipt) => receipt.guid.toLowerCase() === guid)) {
+      return failure4(
+        "missing-receipt",
+        "one receipt for every terminal product GUID",
+        "preserve the producer receipt when handing the product to engine-pack",
+        { guid }
+      );
+    }
+  }
+  const assets = [...product.assets].sort((left, right) => left.guid.localeCompare(right.guid));
+  const document = packageDocument(assets, policy.artifactPath);
+  const packageBytes = new TextEncoder().encode(JSON.stringify(sorted(document)));
+  if (policy.sink !== void 0) {
+    for (const asset of assets) {
+      for (const [key, artifact] of Object.entries(asset.artifacts)) {
+        const path = policy.artifactPath(asset.guid, key);
+        if (!safePath(path)) {
+          return failure4(
+            "invalid-artifact",
+            "package-relative artifact output paths",
+            "repair the finalizer artifact path policy",
+            { guid: asset.guid, key }
+          );
+        }
+        await policy.sink(path, artifact.bytes);
+      }
+    }
+    if (!safePath(policy.packagePath)) {
+      return failure4(
+        "invalid-artifact",
+        "a package-relative package path",
+        "repair the finalizer package path policy",
+        { key: policy.packagePath }
+      );
+    }
+    await policy.sink(policy.packagePath, packageBytes);
+  }
+  return {
+    ok: true,
+    value: {
+      pack: document,
+      packageUrl: packageUrl(policy.base, policy.packagePath),
+      digest: digest(product.assets),
+      receipts: product.receipts,
+      diagnostics: product.diagnostics,
+      sourceRevision: product.sourceRevision,
+      ...product.sourceKey === void 0 ? {} : { sourceKey: product.sourceKey }
+    }
+  };
+}
+async function finalizePackageTransportSource(input, policy) {
+  const sourceRevision = packageTransportRevision(input);
+  const product = {
+    assets: input.assets,
+    receipts: input.receipts ?? input.assets.map((asset) => ({
+      guid: asset.guid,
+      origin: "sourceMeta",
+      status: "succeeded",
+      inputFingerprint: sourceRevision
+    })),
+    diagnostics: input.diagnostics ?? [],
+    sourceRevision,
+    ...input.sourceKey === void 0 ? {} : { sourceKey: input.sourceKey }
+  };
+  const finalized = await finalizePackageProduct(product, policy);
+  if (!finalized.ok) throw finalized.error;
+  return {
+    pack: finalized.value.pack,
+    packageUrl: finalized.value.packageUrl,
+    artifacts: transportArtifacts(product.assets, policy.artifactPath),
+    digest: finalized.value.digest,
+    receipts: finalized.value.receipts,
+    sourceRevision,
+    semantic: JSON.stringify(sorted(finalized.value.pack))
+  };
+}
+function revisionStable(value) {
+  if (value instanceof Uint8Array) {
+    return {
+      byteLength: value.byteLength,
+      digest: createHash("sha256").update(value).digest("hex")
+    };
+  }
+  if (Array.isArray(value)) return value.map(revisionStable);
+  if (value !== null && typeof value === "object") {
+    return Object.fromEntries(
+      Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, item]) => [key, revisionStable(item)])
+    );
+  }
+  return value;
+}
+function packageTransportRevision(value) {
+  return createHash("sha256").update(JSON.stringify(revisionStable(value))).digest("hex");
+}
 function parsePackV2(value) {
   if (!validatePackV2(value)) {
     return err({
@@ -12725,6 +12821,6 @@ function createRuntimePackPublication(input) {
   };
 }
 
-export { AssetGuid, MESH_BIN_DIGEST_BYTES, MESH_BIN_HEADER_V4_BYTES, MESH_BIN_PROJECTION_VERSION, MESH_BIN_VERSION, PACK_PARAMETER_TYPES, PACK_SOURCE_KEY_RE, PARAMETERIZED_PACK_OPERATION_DESCRIPTORS, PARAMETERIZED_PACK_OPERATION_IDS, PackageId, SCRIPTABLE_PACK_ASSET_KINDS, STANDARD_SCRIPTABLE_PACK_SCAN_OPTIONS, buildCatalogProjection, buildOfflineAssetEvidence, calculateCatalogDelta, calculateTopologyDiff, catalogProjectionFor, catalogSourcePathFor, collectMaterialCookRefs, createFileSystemParameterizedPackAuthoringGateway, createFileSystemParameterizedPackAuthoringPort, createMaterialArtifactDigest, createParameterizedPackAuthoringGateway, createRuntimePackPublication, currentProjectionFor, decodeMeshBinHeader, definePack, definePackageId, diffTopology, finalizePackageProduct, finalizePackageTransportSource, findReservedAssetKindConflict, inventoryDigest, isParameterizedPack, isScriptablePackAssetKind, isValidAssetGuidString, isValidPackSourceKey, metaPathForGuid, packageTransportRevision, packageVerification, parsePackAuthoringJson, parsePackJson, parsePackV2, parseParameterizedPackJson, projectAssetRefs, projectCookedMaterialRecord, projectCookedPackageEntry, projectDirectPackJson, projectExternalCatalogEntries, projectPackageCatalog, projectParameterizedPackMeta, projectRuntimeCatalogRow, projectSceneEntityRefs, projectScriptablePackSceneComponents, resolveAssetSource, resolvePackInheritance, resolvePackParameterInheritance, resolvePackParameterValues, scanInventory, serializeCookedMaterialRecord, serializeMaterialCookReceipt, syncAuthorInventory, validateArtifactPath, validateAuthorInventory, validateCookedMaterialRecord, validateMaterialCookReceipt, validateMeta, validatePack, validatePackDefinition, validatePackV2, validateProducerContract, validateProducerOutputs, writeMeshBinHeader };
+export { AssetGuid, MESH_BIN_DIGEST_BYTES, MESH_BIN_HEADER_V4_BYTES, MESH_BIN_PROJECTION_VERSION, MESH_BIN_VERSION, PACK_AUTHORING_OPERATION_DESCRIPTORS, PACK_AUTHORING_OPERATION_IDS, PACK_PARAMETER_TYPES, PACK_SOURCE_KEY_RE, PackageId, SCRIPTABLE_PACK_ASSET_KINDS, STANDARD_SCRIPTABLE_PACK_SCAN_OPTIONS, buildCatalogProjection, buildOfflineAssetEvidence, calculateCatalogDelta, calculateTopologyDiff, catalogProjectionFor, catalogSourcePathFor, collectMaterialCookRefs, createFileSystemPackAuthoringGateway, createFileSystemPackAuthoringPort, createMaterialArtifactDigest, createPackAuthoringGateway, createRuntimePackPublication, currentProjectionFor, decodeMeshBinHeader, definePack, definePackageId, diffTopology, finalizePackageProduct, finalizePackageTransportSource, findReservedAssetKindConflict, hasPackParameters, inventoryDigest, isScriptablePackAssetKind, isValidAssetGuidString, isValidPackSourceKey, metaPathForGuid, packageTransportRevision, packageVerification, parsePackSourceJson, parsePackV2, projectAssetRefs, projectCookedMaterialRecord, projectCookedPackageEntry, projectDirectPackJson, projectExternalCatalogEntries, projectPackageCatalog, projectRuntimeCatalogRow, projectSceneEntityRefs, projectScriptablePackMeta, projectScriptablePackSceneComponents, resolveAssetSource, resolvePackInheritance, resolvePackParameterInheritance, resolvePackParameterValues, scanInventory, serializeCookedMaterialRecord, serializeMaterialCookReceipt, syncAuthorInventory, validateArtifactPath, validateAuthorInventory, validateCookedMaterialRecord, validateMaterialCookReceipt, validateMeta, validatePack, validatePackDefinition, validatePackV2, validateProducerContract, validateProducerOutputs, writeMeshBinHeader };
 //# sourceMappingURL=build.mjs.map
 //# sourceMappingURL=build.mjs.map