@forgeax/engine-pack 0.1.3 → 0.1.4

package/dist/scanner.mjs

@@ -1,9 +1,9 @@
+import { createHash } from 'crypto';
 import { stat, readFile, readdir, realpath, mkdtemp, rm } from 'fs/promises';
 import { join, basename, dirname, resolve, posix, extname } from 'path';
 import { PACK_ERROR_HINTS, ok, err, validateSourceOverrideMap, AssetError, ImportError } from '@forgeax/engine-types';
 import { readFileSync, existsSync } from 'fs';
 import { uuidv7obj } from 'uuidv7';
-import { createHash } from 'crypto';
 import { tmpdir } from 'os';
 import { fileURLToPath } from 'url';
 import { Worker } from 'worker_threads';
@@ -7134,11 +7134,23 @@ function validateProducerOutputs(outputs) {
   }
   return { ok: true, value: outputs };
 }
+
+// src/deriveAssetName.ts
 function baseName(p) {
   const trimmed = p.replace(/[/\\]+$/, "");
   const idx = Math.max(trimmed.lastIndexOf("/"), trimmed.lastIndexOf("\\"));
   return idx === -1 ? trimmed : trimmed.slice(idx + 1);
 }
+function deriveAssetName(packagePath, assetCount, storedName) {
+  if (packagePath === null) {
+    return "";
+  }
+  {
+    return baseName(packagePath);
+  }
+}
+
+// src/resolve-asset-source.ts
 function deriveSourceName(metaFileName) {
   return metaFileName.replace(/\.meta\.json$/, "");
 }
@@ -7150,7 +7162,7 @@ function isPathEscape(pathDir, resolved) {
 function resolveAssetSource(metaPath, source, paths) {
   if (source === void 0) {
     const metaDir = dirname(metaPath);
-    const metaName = baseName(metaPath);
+    const metaName = deriveAssetName(metaPath);
     const derived = deriveSourceName(metaName);
     return ok(resolve(metaDir, derived));
   }
@@ -7647,6 +7659,22 @@ var SCRIPTABLE_PACK_ASSET_KINDS = [
 function isScriptablePackAssetKind(value) {
   return SCRIPTABLE_PACK_ASSET_KINDS.includes(value);
 }
+function sceneComponentFieldType(value) {
+  if (typeof value === "string") return value;
+  if (isRecord2(value) && typeof value.type === "string") return value.type;
+  return void 0;
+}
+function projectScriptablePackSceneComponents(components) {
+  return (components ?? []).map((component) => ({
+    name: component.name,
+    fields: Object.fromEntries(
+      Object.entries(component.fields).map(([fieldName, field]) => [
+        fieldName,
+        sceneComponentFieldType(field)
+      ])
+    )
+  }));
+}
 var SCRIPTABLE_PACK_REQUEST_ID_SCHEMA = {
   type: "string",
   minLength: 1,
@@ -7872,11 +7900,20 @@ function freezeDefinition(definition) {
       guid.slice()
     ])
   );
+  const sceneComponents = definition.sceneComponents === void 0 ? void 0 : Object.freeze(
+    projectScriptablePackSceneComponents(definition.sceneComponents).map(
+      (component) => Object.freeze({
+        ...component,
+        fields: Object.freeze({ ...component.fields })
+      })
+    )
+  );
   return Object.freeze({
     ...definition,
     packageId: definition.packageId.slice(),
     assets: Object.freeze(assets),
-    externalAssets: Object.freeze(externalAssets)
+    externalAssets: Object.freeze(externalAssets),
+    ...sceneComponents === void 0 ? {} : { sceneComponents }
   });
 }
 function validateScriptablePackDefinition(value, sourcePath) {
@@ -7907,6 +7944,63 @@ function validateScriptablePackDefinition(value, sourcePath) {
       sourcePath
     );
   }
+  if (value.sceneComponents !== void 0) {
+    if (!Array.isArray(value.sceneComponents)) {
+      return invalid(
+        "$.sceneComponents",
+        "an array of component tokens or neutral schema rows when present",
+        value.sceneComponents,
+        sourcePath
+      );
+    }
+    const componentNames = /* @__PURE__ */ new Set();
+    for (const [componentIndex, component] of value.sceneComponents.entries()) {
+      if (!isRecord2(component)) {
+        return invalid(
+          `$.sceneComponents[${componentIndex}]`,
+          "a component token or neutral schema row",
+          component,
+          sourcePath
+        );
+      }
+      if (typeof component.name !== "string" || component.name.trim().length === 0) {
+        return invalid(
+          `$.sceneComponents[${componentIndex}].name`,
+          "a non-empty component name",
+          component.name,
+          sourcePath
+        );
+      }
+      if (componentNames.has(component.name)) {
+        return invalid(
+          `$.sceneComponents[${componentIndex}].name`,
+          "component names to be unique within one ScriptablePack",
+          component.name,
+          sourcePath
+        );
+      }
+      componentNames.add(component.name);
+      if (!isRecord2(component.fields)) {
+        return invalid(
+          `$.sceneComponents[${componentIndex}].fields`,
+          "a field-name to schema-type object",
+          component.fields,
+          sourcePath
+        );
+      }
+      for (const [fieldName, field] of Object.entries(component.fields)) {
+        const type = sceneComponentFieldType(field);
+        if (fieldName.trim().length === 0 || type === void 0 || type.trim().length === 0) {
+          return invalid(
+            `$.sceneComponents[${componentIndex}].fields`,
+            "field names with non-empty string schema types",
+            field,
+            sourcePath
+          );
+        }
+      }
+    }
+  }
   if (typeof value.build !== "function") {
     return invalid("$.build", "a build(assetReader) function", value.build, sourcePath);
   }
@@ -8010,7 +8104,7 @@ function scriptablePackWorkerExecArgv() {
   const inherited = process.execArgv.filter((arg) => !arg.startsWith("--input-type"));
   return inherited.includes(IMPORT_META_RESOLVE_FLAG) ? inherited : [...inherited, IMPORT_META_RESOLVE_FLAG];
 }
-async function resolveRelativeSourceImport(sourcePath, specifier) {
+async function resolveRelativeImport(sourcePath, specifier) {
   if (!specifier.startsWith(".")) return void 0;
   const raw = resolve(dirname(sourcePath), specifier);
   const candidates = extname(raw).length > 0 ? [raw] : [
@@ -8031,19 +8125,20 @@ async function resolveRelativeSourceImport(sourcePath, specifier) {
   }
   return void 0;
 }
-async function inventoryScriptablePackSource(sourcePath) {
-  const pending = [await realpath(sourcePath)];
+async function inventoryScriptablePackSource(sourcePath, initialSourceText) {
+  const root = await realpath(sourcePath);
+  const pending = [root];
   const seen = /* @__PURE__ */ new Set();
   const entries = [];
   while (pending.length > 0) {
     const path = pending.pop();
     if (path === void 0 || seen.has(path)) continue;
     seen.add(path);
-    const bytes = await readFile(path);
+    const bytes = path === root && initialSourceText !== void 0 ? new TextEncoder().encode(initialSourceText) : await readFile(path);
     entries.push({ path, digest: `sha256:${createHash("sha256").update(bytes).digest("hex")}` });
-    const imports = ts.preProcessFile(new TextDecoder().decode(bytes), true, true).importedFiles;
-    for (const imported of imports) {
-      const resolved = await resolveRelativeSourceImport(path, imported.fileName);
+    const source = new TextDecoder().decode(bytes);
+    for (const imported of ts.preProcessFile(source, true, true).importedFiles) {
+      const resolved = await resolveRelativeImport(path, imported.fileName);
       if (resolved !== void 0) pending.push(await realpath(resolved));
     }
   }
@@ -8117,6 +8212,7 @@ var WorkerScriptablePackExecutor = class {
         if (message === null || typeof message !== "object") return;
         const value = message;
         if (value.kind === "loaded") {
+          worker.unref();
           worker.off("message", onMessage);
           resolveLoad({
             default: value.definition === void 0 ? void 0 : {
@@ -8194,247 +8290,6 @@ 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);
 }
-var ReusableWorkerScriptablePackExecutor = class {
-  constructor(maxTasksPerWorker, release) {
-    this.maxTasksPerWorker = maxTasksPerWorker;
-    this.release = release;
-    this.worker = new Worker(scriptablePackWorkerUrl(), {
-      workerData: { mode: "reusable" },
-      execArgv: scriptablePackWorkerExecArgv(),
-      resourceLimits: { maxOldGenerationSizeMb: 256, maxYoungGenerationSizeMb: 64 }
-    });
-    this.worker.on("message", (message) => this.onMessage(message));
-    this.worker.on("error", (error) => {
-      this.failed = true;
-      this.rejectActive(error);
-      void this.dispose("failure");
-    });
-    this.worker.on("exit", (code) => {
-      if (code === 0 || this.disposal !== void 0) return;
-      this.failed = true;
-      this.rejectActive(new Error(`ScriptablePack worker exited with code ${code}`));
-      void this.dispose("failure");
-    });
-    this.worker.unref();
-  }
-  maxTasksPerWorker;
-  release;
-  worker;
-  compileRootReady = mkdtemp(resolve(tmpdir(), "forgeax-scriptable-pack-pool-"));
-  compileRoot;
-  nextLoadId = 0;
-  nextBuildId = 0;
-  pendingLoad;
-  build;
-  disposal;
-  forceDispose = false;
-  failed = false;
-  taskCount = 0;
-  released = false;
-  async load(sourcePath) {
-    const activeDisposal = this.disposal;
-    if (activeDisposal !== void 0) {
-      await activeDisposal;
-      if (this.failed) {
-        return Promise.reject(new Error("ScriptablePack executor is not leased"));
-      }
-      this.disposal = void 0;
-    }
-    this.released = false;
-    if (this.pendingLoad !== void 0 || this.build !== void 0) {
-      return Promise.reject(new Error("ScriptablePack executor already has an active task"));
-    }
-    const compileRoot = this.compileRoot ?? await this.compileRootReady;
-    if (this.disposal !== void 0) {
-      const disposal = this.disposal;
-      await disposal;
-      if (this.failed) {
-        return Promise.reject(new Error("ScriptablePack executor is not leased"));
-      }
-      this.disposal = void 0;
-    }
-    const loadId = this.nextLoadId++;
-    this.compileRoot = compileRoot;
-    this.taskCount += 1;
-    return new Promise((resolveLoad, rejectLoad) => {
-      this.pendingLoad = { id: loadId, resolve: resolveLoad, reject: rejectLoad };
-      try {
-        this.worker.postMessage({
-          kind: "load",
-          loadId,
-          sourcePath: resolve(sourcePath),
-          compileRoot
-        });
-      } catch (error) {
-        this.pendingLoad = void 0;
-        rejectLoad(error);
-        void this.dispose("failure");
-      }
-    });
-  }
-  dispose(reason = "complete") {
-    if (reason === "failure") this.forceDispose = true;
-    const activeDisposal = this.disposal;
-    if (activeDisposal !== void 0) {
-      return activeDisposal;
-    }
-    this.rejectActive(new Error(`ScriptablePack task disposed during ${reason}`));
-    this.disposal = (async () => {
-      const compileRoot = this.compileRoot ?? await this.compileRootReady;
-      const reusable = reason === "complete" && !this.failed && !this.forceDispose && this.taskCount < this.maxTasksPerWorker;
-      this.forceDispose = false;
-      if (!reusable) {
-        this.compileRoot = void 0;
-        await this.worker.terminate();
-        await rm(compileRoot, { recursive: true, force: true });
-      }
-      this.released = true;
-      this.disposal = void 0;
-      this.release(this, reusable);
-    })();
-    return this.disposal;
-  }
-  rejectActive(error) {
-    const loading = this.pendingLoad;
-    this.pendingLoad = void 0;
-    loading?.reject(error);
-    const building = this.build;
-    this.build = void 0;
-    building?.reject(error);
-  }
-  runBuild(reader) {
-    if (this.released || this.disposal !== void 0) {
-      return Promise.reject(new Error("ScriptablePack executor is not leased"));
-    }
-    if (this.build !== void 0) {
-      return Promise.reject(new Error("ScriptablePack worker already has an active build"));
-    }
-    const id = this.nextBuildId++;
-    return new Promise((resolveBuild, rejectBuild) => {
-      this.build = { id, reader, resolve: resolveBuild, reject: rejectBuild };
-      try {
-        this.worker.postMessage({ kind: "build", buildId: id });
-      } catch (error) {
-        this.build = void 0;
-        rejectBuild(error);
-        void this.dispose("failure");
-      }
-    });
-  }
-  onMessage(message) {
-    if (message === null || typeof message !== "object") return;
-    const value = message;
-    const loading = this.pendingLoad;
-    if (loading !== void 0 && value.kind === "loaded" && value.loadId === loading.id) {
-      this.pendingLoad = void 0;
-      loading.resolve({
-        default: value.definition === void 0 ? void 0 : {
-          ...value.definition,
-          build: (reader) => this.runBuild(reader)
-        }
-      });
-      return;
-    }
-    if (loading !== void 0 && value.kind === "load-threw" && value.loadId === loading.id) {
-      this.pendingLoad = void 0;
-      loading.reject(hydrateFailure(value.error));
-      return;
-    }
-    const active = this.build;
-    if (active === void 0 || value.buildId !== active.id) return;
-    if (value.kind === "asset-read" && typeof value.readId === "number") {
-      void active.reader.readByGuid(value.guid).then(
-        (result) => this.worker.postMessage({
-          kind: "asset-result",
-          readId: value.readId,
-          result: result.ok === true ? result : { ...result, error: serializeFailure(result.error) }
-        })
-      ).catch((error) => {
-        if (this.build?.id !== active.id) return;
-        this.build = void 0;
-        active.reject(error);
-        void this.dispose("failure");
-      });
-      return;
-    }
-    this.build = void 0;
-    if (value.kind === "build-result") active.resolve(value.result);
-    else if (value.kind === "build-threw") active.reject(hydrateFailure(value.error));
-    else this.build = active;
-  }
-};
-var DefaultScriptablePackModuleExecutorPool = class {
-  maxWorkers;
-  maxTasksPerWorker;
-  idle = [];
-  waiters = [];
-  executors = /* @__PURE__ */ new Set();
-  workerCount = 0;
-  closed = false;
-  constructor(options = {}) {
-    this.maxWorkers = Math.max(1, Math.trunc(options.maxWorkers ?? 2));
-    this.maxTasksPerWorker = Math.max(1, Math.trunc(options.maxTasksPerWorker ?? 32));
-  }
-  acquire() {
-    if (this.closed) return Promise.reject(new Error("ScriptablePack executor pool is closed"));
-    const executor = this.idle.pop();
-    if (executor !== void 0) return Promise.resolve(executor);
-    if (this.workerCount < this.maxWorkers) {
-      this.workerCount += 1;
-      return Promise.resolve(this.createExecutor());
-    }
-    return new Promise(
-      (resolveAcquire, rejectAcquire) => this.waiters.push({ resolve: resolveAcquire, reject: rejectAcquire })
-    );
-  }
-  async dispose() {
-    if (this.closed) return;
-    this.closed = true;
-    const waiters = this.waiters.splice(0);
-    for (const waiter of waiters) {
-      waiter.reject(new Error("ScriptablePack executor pool is closed"));
-    }
-    this.idle.splice(0);
-    await Promise.all([...this.executors].map((executor) => executor.dispose("failure")));
-  }
-  createExecutor() {
-    const executor = new ReusableWorkerScriptablePackExecutor(
-      this.maxTasksPerWorker,
-      (executor2, reusable) => {
-        if (this.closed) {
-          this.executors.delete(executor2);
-          if (!reusable) this.workerCount -= 1;
-          return;
-        }
-        if (!reusable) {
-          this.executors.delete(executor2);
-          this.workerCount -= 1;
-        } else {
-          this.idle.push(executor2);
-        }
-        this.drain();
-      }
-    );
-    this.executors.add(executor);
-    return executor;
-  }
-  drain() {
-    if (this.closed) return;
-    while (this.waiters.length > 0) {
-      const idle = this.idle.pop();
-      if (idle !== void 0) {
-        this.waiters.shift()?.resolve(idle);
-        continue;
-      }
-      if (this.workerCount >= this.maxWorkers) return;
-      this.workerCount += 1;
-      this.waiters.shift()?.resolve(this.createExecutor());
-    }
-  }
-};
-function createScriptablePackModuleExecutorPool(options = {}) {
-  return new DefaultScriptablePackModuleExecutorPool(options);
-}
 function loadFailure(sourcePath, reason, phase, diagnostic, timeoutMs) {
   return err({
     code: "pack-source-load-failed",
@@ -8545,6 +8400,9 @@ function ok3(value) {
 function packErr(error) {
   return { ok: false, error };
 }
+var STANDARD_SCRIPTABLE_PACK_SCAN_OPTIONS = Object.freeze(
+  {}
+);
 var BLACKLIST = /* @__PURE__ */ new Set([
   "node_modules",
   ".forgeax-harness",
@@ -8556,6 +8414,33 @@ var BLACKLIST = /* @__PURE__ */ new Set([
   "coverage"
 ]);
 var SCANNER_BLACKLIST = BLACKLIST;
+async function readValidatedJson(path, code, validate) {
+  let raw;
+  let parsed;
+  try {
+    raw = await readFile(path, "utf-8");
+    parsed = JSON.parse(raw);
+  } catch {
+    return packErr(
+      makePackError(code, {
+        path,
+        ajvErrors: [{ instancePath: "", message: "JSON parse failed" }]
+      })
+    );
+  }
+  if (!validate(parsed)) {
+    return packErr(
+      makePackError(code, {
+        path,
+        ajvErrors: (validate.errors ?? []).map((error) => ({
+          instancePath: error.instancePath ?? "",
+          message: error.message ?? "unknown ajv error"
+        }))
+      })
+    );
+  }
+  return ok3({ raw, parsed });
+}
 function makePackError(code, detail) {
   return new PackError({
     code,
@@ -8578,7 +8463,7 @@ function* extractMountSourceGuids(asset) {
     yield resolved.toLowerCase();
   }
 }
-async function scanInventory(roots, opts = {}) {
+async function scanValidated(roots, opts = {}, capture) {
   const rawPaths = [];
   const explicitRootSet = new Set(roots);
   async function traverse(dir) {
@@ -8623,34 +8508,10 @@ async function scanInventory(roots, opts = {}) {
   const scriptablePaths = rawPaths.filter((p) => p.endsWith(".pack.ts"));
   const guidToPath = /* @__PURE__ */ new Map();
   const packRefs = /* @__PURE__ */ new Map();
-  const scriptablePackMeta = /* @__PURE__ */ new Map();
-  const metaByGuid = /* @__PURE__ */ new Map();
-  const declarations = [];
   for (const packPath of packPaths) {
-    let parsed;
-    try {
-      const raw = await readFile(packPath, "utf-8");
-      parsed = JSON.parse(raw);
-    } catch {
-      return packErr(
-        makePackError("pack-malformed-pack", {
-          path: packPath,
-          ajvErrors: [{ instancePath: "", message: "JSON parse failed" }]
-        })
-      );
-    }
-    const valid = validatePack(parsed);
-    if (!valid) {
-      return packErr(
-        makePackError("pack-malformed-pack", {
-          path: packPath,
-          ajvErrors: (validatePack.errors ?? []).map((e) => ({
-            instancePath: e.instancePath,
-            message: e.message ?? "unknown ajv error"
-          }))
-        })
-      );
-    }
+    const loaded = await readValidatedJson(packPath, "pack-malformed-pack", validatePack);
+    if (!loaded.ok) return loaded;
+    const { raw, parsed } = loaded.value;
     const packageContract = validateProducerContract(parsed);
     if (!packageContract.ok) {
       return packErr(
@@ -8692,7 +8553,12 @@ async function scanInventory(roots, opts = {}) {
         }
       }
       const topologyContract = validateProducerOutputs(
-        producerAssets
+        producerAssets.map((asset, sourceIndex) => ({
+          guid: asset.guid,
+          kind: asset.kind,
+          sourceIndex: asset.sourceIndex ?? sourceIndex,
+          ...asset.sourceKey === void 0 ? {} : { sourceKey: asset.sourceKey }
+        }))
       );
       if (!topologyContract.ok) {
         return packErr(
@@ -8733,66 +8599,24 @@ async function scanInventory(roots, opts = {}) {
         );
       }
       guidToPath.set(normalizedGuid, packPath);
-      const existingRefs = packRefs.get(normalizedGuid) ?? [];
-      for (const ref of asset.refs) {
-        existingRefs.push(ref.toLowerCase());
-      }
-      for (const guid of extractMountSourceGuids(asset)) {
-        existingRefs.push(guid);
-      }
-      packRefs.set(normalizedGuid, existingRefs);
-    }
-    const outputs = packObj.assets.map((asset) => ({
-      guid: asset.guid,
-      ...asset.sourceKey === void 0 ? {} : { sourceKey: asset.sourceKey },
-      ...asset.sourceIndex === void 0 ? {} : { sourceIndex: asset.sourceIndex },
-      kind: asset.kind,
-      ...asset.name === void 0 ? {} : { name: asset.name },
-      ...asset.execution === void 0 ? {} : { execution: asset.execution },
-      refs: asset.refs
-    }));
-    declarations.push({
+      packRefs.set(normalizedGuid, [
+        ...asset.refs.map((ref) => ref.toLowerCase()),
+        ...extractMountSourceGuids(asset)
+      ]);
+    }
+    capture?.declarations.set(packPath, {
+      format: "pack.json",
       sourcePath: packPath,
-      canonicalSourcePath: packPath.replace(/\\/g, "/"),
-      producer: "direct-pack",
-      ...packObj.packageId === void 0 ? {} : { packageId: packObj.packageId },
-      projectedMeta: {
-        schemaVersion: "2.0.0",
-        ...packObj.packageId === void 0 ? {} : { packageId: packObj.packageId },
-        outputs,
-        externalGuids: outputs.flatMap((output) => output.refs)
-      },
-      outputs,
-      externalGuids: outputs.flatMap((output) => output.refs),
-      diagnostics: []
+      sourceRevision: `sha256:${createHash("sha256").update(raw).digest("hex")}`,
+      sourceText: raw,
+      value: packObj
     });
   }
   const { paths: assetPaths } = loadAssetConfig(process.cwd());
   for (const metaPath of metaPaths) {
-    let parsed;
-    try {
-      const raw = await readFile(metaPath, "utf-8");
-      parsed = JSON.parse(raw);
-    } catch {
-      return packErr(
-        makePackError("pack-malformed-meta", {
-          path: metaPath,
-          ajvErrors: [{ instancePath: "", message: "JSON parse failed" }]
-        })
-      );
-    }
-    const valid = validateMeta(parsed);
-    if (!valid) {
-      return packErr(
-        makePackError("pack-malformed-meta", {
-          path: metaPath,
-          ajvErrors: (validateMeta.errors ?? []).map((e) => ({
-            instancePath: e.instancePath,
-            message: e.message ?? "unknown ajv error"
-          }))
-        })
-      );
-    }
+    const loaded = await readValidatedJson(metaPath, "pack-malformed-meta", validateMeta);
+    if (!loaded.ok) return loaded;
+    const { raw, parsed } = loaded.value;
     const metaContract = validateProducerContract(parsed);
     if (!metaContract.ok) {
       return packErr(
@@ -8803,6 +8627,12 @@ async function scanInventory(roots, opts = {}) {
       );
     }
     const metaObj = parsed;
+    capture?.declarations.set(metaPath, {
+      format: "meta.json",
+      sourcePath: metaPath,
+      sourceRevision: `sha256:${createHash("sha256").update(raw).digest("hex")}`,
+      value: metaObj
+    });
     for (const sub of metaObj.subAssets) {
       if (!isValidAssetGuidString(sub.guid)) {
         return packErr(
@@ -8823,13 +8653,10 @@ async function scanInventory(roots, opts = {}) {
         );
       }
       guidToPath.set(normalizedGuid, metaPath);
-      metaByGuid.set(normalizedGuid, metaPath);
     }
     const producerSubAssets = metaObj.subAssets.length > 1 ? metaObj.subAssets : [];
     if (producerSubAssets.length > 0) {
-      const topologyContract = validateProducerOutputs(
-        producerSubAssets
-      );
+      const topologyContract = validateProducerOutputs(producerSubAssets);
       if (!topologyContract.ok) {
         return packErr(
           makePackError("pack-malformed-meta", {
@@ -8854,113 +8681,80 @@ async function scanInventory(roots, opts = {}) {
         })
       );
     }
-    const outputs = metaObj.subAssets.map((sub) => ({
-      guid: sub.guid,
-      ...sub.sourceKey === void 0 ? {} : { sourceKey: sub.sourceKey },
-      sourceIndex: sub.sourceIndex,
-      kind: sub.kind,
-      ...sub.name === void 0 ? {} : { name: sub.name },
-      refs: []
-    }));
-    const externalGuids = (metaObj.importSettings?.externalAssets ?? []).flatMap(
-      (entry) => typeof entry.guid === "string" ? [entry.guid] : []
-    );
-    declarations.push({
-      sourcePath: metaPath,
-      canonicalSourcePath: metaPath.replace(/\\/g, "/"),
-      producer: "source-meta",
-      ...metaObj.packageId === void 0 ? {} : { packageId: metaObj.packageId },
-      projectedMeta: {
-        ...metaObj.packageId === void 0 ? {} : { packageId: metaObj.packageId },
-        ...metaObj.importer === void 0 ? {} : { importer: metaObj.importer },
-        ...metaObj.source === void 0 ? {} : { source: metaObj.source },
-        ...metaObj.name === void 0 ? {} : { name: metaObj.name },
-        outputs,
-        externalGuids
-      },
-      outputs,
-      externalGuids,
-      diagnostics: []
-    });
   }
-  const scriptablePackExecutorPool = scriptablePaths.length === 0 || opts.scriptablePackLoad?.executor !== void 0 ? void 0 : createScriptablePackModuleExecutorPool();
-  try {
-    for (const sourcePath of scriptablePaths) {
-      const executor = await scriptablePackExecutorPool?.acquire();
-      const loaded = await loadScriptablePack(sourcePath, {
-        ...opts.scriptablePackLoad,
-        metadataOnly: true,
-        ...executor === void 0 ? {} : { executor }
-      });
-      if (!loaded.ok) {
-        const diagnostic = "diagnostic" in loaded.error.detail ? loaded.error.detail.diagnostic : void 0;
-        return packErr(
-          makePackError("pack-malformed-meta", {
-            path: sourcePath,
-            ajvErrors: [
-              {
-                instancePath: "",
-                message: diagnostic === void 0 ? loaded.error.code : `${loaded.error.code}: ${diagnostic}`
-              }
-            ]
-          })
-        );
-      }
-      const meta = projectScriptablePackMeta(loaded.value, sourcePath);
-      scriptablePackMeta.set(sourcePath, meta);
-      const sourceClosure = await inventoryScriptablePackSource(sourcePath);
-      const topology = validateProducerOutputs(
-        meta.subAssets
+  for (const sourcePath of scriptablePaths) {
+    let source;
+    try {
+      source = await readFile(sourcePath, "utf8");
+    } catch {
+      return packErr(
+        makePackError("pack-malformed-meta", {
+          path: sourcePath,
+          ajvErrors: [{ instancePath: "", message: "ScriptablePack source read failed" }]
+        })
+      );
+    }
+    const loaded = await loadScriptablePack(sourcePath, {
+      ...opts.scriptablePack ?? {},
+      ...capture === void 0 ? { metadataOnly: true } : {}
+    });
+    if (!loaded.ok) {
+      const diagnostic = "diagnostic" in loaded.error.detail ? loaded.error.detail.diagnostic : void 0;
+      return packErr(
+        makePackError("pack-malformed-meta", {
+          path: sourcePath,
+          ajvErrors: [
+            {
+              instancePath: "",
+              message: diagnostic === void 0 ? loaded.error.code : `${loaded.error.code}: ${diagnostic}`
+            }
+          ]
+        })
+      );
+    }
+    let sourceClosure;
+    try {
+      sourceClosure = await inventoryScriptablePackSource(sourcePath, source);
+    } catch {
+      return packErr(
+        makePackError("pack-malformed-meta", {
+          path: sourcePath,
+          ajvErrors: [{ instancePath: "", message: "ScriptablePack source closure read failed" }]
+        })
       );
-      if (!topology.ok) {
+    }
+    const meta = projectScriptablePackMeta(loaded.value, sourcePath);
+    const topology = validateProducerOutputs(meta.subAssets);
+    if (!topology.ok) {
+      return packErr(
+        makePackError("pack-malformed-meta", {
+          path: sourcePath,
+          ajvErrors: [{ instancePath: "/subAssets", message: topology.error.code }]
+        })
+      );
+    }
+    const declaration = {
+      sourcePath,
+      sourceRevision: `sha256:${createHash("sha256").update(source).digest("hex")}`,
+      meta,
+      definition: loaded.value,
+      sourceClosure
+    };
+    capture?.declarations.set(sourcePath, {
+      format: "pack.ts",
+      ...declaration,
+      value: meta
+    });
+    for (const sub of meta.subAssets) {
+      const guid = sub.guid.toLowerCase();
+      const existing = guidToPath.get(guid);
+      if (existing !== void 0) {
         return packErr(
-          makePackError("pack-malformed-meta", {
-            path: sourcePath,
-            ajvErrors: [{ instancePath: "/subAssets", message: topology.error.code }]
-          })
+          makePackError("pack-guid-collision", { paths: [existing, sourcePath], guid })
         );
       }
-      for (const sub of meta.subAssets) {
-        const guid = sub.guid.toLowerCase();
-        const existing = guidToPath.get(guid);
-        if (existing !== void 0) {
-          return packErr(
-            makePackError("pack-guid-collision", { paths: [existing, sourcePath], guid })
-          );
-        }
-        guidToPath.set(guid, sourcePath);
-      }
-      const outputs = meta.subAssets.map((sub) => ({
-        guid: sub.guid,
-        sourceKey: sub.sourceKey,
-        sourceIndex: sub.sourceIndex,
-        kind: sub.kind,
-        ...sub.name === void 0 ? {} : { name: sub.name },
-        refs: []
-      }));
-      const externalGuids = meta.importSettings.externalAssets.map((entry) => entry.guid);
-      declarations.push({
-        sourcePath,
-        canonicalSourcePath: sourcePath.replace(/\\/g, "/"),
-        producer: "scriptable-pack",
-        packageId: meta.packageId,
-        projectedMeta: {
-          schemaVersion: meta.schemaVersion,
-          packageId: meta.packageId,
-          importer: meta.importer,
-          source: meta.source,
-          ...meta.name === void 0 ? {} : { name: meta.name },
-          outputs,
-          externalGuids
-        },
-        outputs,
-        externalGuids,
-        sourceClosure,
-        diagnostics: []
-      });
+      guidToPath.set(guid, sourcePath);
     }
-  } finally {
-    await scriptablePackExecutorPool?.dispose();
   }
   const visited = /* @__PURE__ */ new Set();
   const recStack = /* @__PURE__ */ new Set();
@@ -8993,23 +8787,33 @@ async function scanInventory(roots, opts = {}) {
       }
     }
   }
-  const declarationsByPath = new Map(
-    declarations.map((declaration) => [declaration.sourcePath, declaration])
-  );
-  return ok3({
-    paths: rawPaths,
-    scriptablePackMeta,
-    declarations,
-    declarationsByPath,
-    sourceByGuid: new Map(guidToPath),
-    metaByGuid
-  });
+  return ok3(rawPaths);
 }
 async function scan(roots, opts = {}) {
-  const inventory = await scanInventory(roots, opts);
-  return inventory.ok ? ok3([...inventory.value.paths]) : inventory;
+  return scanValidated(roots, opts);
+}
+async function scanInventory(roots, opts = {}) {
+  const declarations = /* @__PURE__ */ new Map();
+  const scanned = await scanValidated(roots, opts, { declarations });
+  if (!scanned.ok) return scanned;
+  const inventory = [];
+  for (const sourcePath of scanned.value) {
+    const declaration = declarations.get(sourcePath);
+    if (declaration?.format !== "pack.json") continue;
+    for (const [index, asset] of declaration.value.assets.entries()) {
+      inventory.push({
+        guid: asset.guid,
+        kind: asset.kind,
+        sourcePath,
+        sourceRevision: declaration.sourceRevision,
+        ...asset.sourceKey === void 0 ? {} : { sourceKey: asset.sourceKey },
+        ...asset.sourceIndex === void 0 ? { sourceIndex: index } : { sourceIndex: asset.sourceIndex }
+      });
+    }
+  }
+  return ok3({ paths: scanned.value, inventory, declarations });
 }
 
-export { SCANNER_BLACKLIST, scan, scanInventory };
+export { SCANNER_BLACKLIST, STANDARD_SCRIPTABLE_PACK_SCAN_OPTIONS, scan, scanInventory };
 //# sourceMappingURL=scanner.mjs.map
 //# sourceMappingURL=scanner.mjs.map