@forgeax/game 0.3.6 → 0.3.8

package/assets/extensions/asset3d/cli.mjs

@@ -0,0 +1,2090 @@
+// extensions/asset3d/src/credentials.ts
+import { chmodSync, existsSync, lstatSync, readFileSync, statSync, unlinkSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname as dirname2, isAbsolute, resolve } from "node:path";
+
+// extensions/asset3d/src/fs.ts
+import { closeSync, fsyncSync, mkdirSync, openSync, renameSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+function ensurePrivateDir(path) {
+  mkdirSync(path, { recursive: true, mode: 448 });
+}
+function atomicWrite(path, data, mode = 384) {
+  ensurePrivateDir(dirname(path));
+  const temp = `${path}.tmp-${process.pid}-${crypto.randomUUID()}`;
+  const fd = openSync(temp, "wx", mode);
+  try {
+    writeFileSync(fd, data);
+    fsyncSync(fd);
+  } finally {
+    closeSync(fd);
+  }
+  renameSync(temp, path);
+  const dirFd = openSync(dirname(path), "r");
+  try {
+    fsyncSync(dirFd);
+  } finally {
+    closeSync(dirFd);
+  }
+}
+
+// extensions/asset3d/src/credentials.ts
+var AW_CREDENTIAL_SCHEMA = "forgeax.asset3d-credential/1.0.0";
+var AW_KEY_ENV = "FORGEAX_ASSET3D_AW_SANDBOX_KEY";
+var MAX_CREDENTIAL_BYTES = 4096;
+function validateKey(value) {
+  if (!value || value.length > 2048 || [...value].some((character) => {
+    const code = character.charCodeAt(0);
+    return code < 32 || code === 127;
+  })) {
+    throw new Error("asset3d_api_key_invalid: expected a non-empty printable key");
+  }
+  return value;
+}
+function defaultAwCredentialFile() {
+  const configured = process.env.FORGEAX_ASSET3D_CREDENTIAL_FILE;
+  return resolve(configured || resolve(homedir(), ".forgeax", "credentials", "asset3d-aw.json"));
+}
+function readAwCredential(pathInput) {
+  const path = resolve(pathInput);
+  if (!isAbsolute(pathInput))
+    throw new Error("asset3d_credential_path_invalid: absolute path required");
+  if (!existsSync(path))
+    return;
+  try {
+    const metadata = lstatSync(path);
+    const wrongOwner = typeof process.getuid === "function" && metadata.uid !== process.getuid();
+    if (!metadata.isFile() || metadata.isSymbolicLink() || wrongOwner)
+      throw new Error;
+    if ((metadata.mode & 63) !== 0 || metadata.size < 1 || metadata.size > MAX_CREDENTIAL_BYTES)
+      throw new Error;
+    const parsed = JSON.parse(readFileSync(path, "utf8"));
+    if (Object.keys(parsed).sort().join(",") !== "provider,sandboxKey,schemaVersion")
+      throw new Error;
+    if (parsed.schemaVersion !== AW_CREDENTIAL_SCHEMA || parsed.provider !== "aw" || typeof parsed.sandboxKey !== "string")
+      throw new Error;
+    return validateKey(parsed.sandboxKey);
+  } catch {
+    throw new Error("asset3d_credential_invalid: credential file must be an owned 0600 regular file with the supported schema");
+  }
+}
+async function promptAwKey() {
+  if (!process.stdin.isTTY || !process.stdout.isTTY || typeof process.stdin.setRawMode !== "function") {
+    throw new Error(`asset3d_api_key_required: set ${AW_KEY_ENV} or rerun in an interactive terminal`);
+  }
+  process.stdout.write("AW Asset3D Sandbox Key (input hidden): ");
+  const input = process.stdin;
+  const previousRaw = input.isRaw;
+  input.setRawMode(true);
+  input.resume();
+  input.setEncoding("utf8");
+  try {
+    const value = await new Promise((resolveValue, reject) => {
+      let collected = "";
+      const onData = (chunk) => {
+        for (const character of chunk) {
+          if (character === "\x03") {
+            input.off("data", onData);
+            reject(new Error("asset3d_api_key_input_cancelled"));
+            return;
+          }
+          if (character === "\r" || character === `
+`) {
+            input.off("data", onData);
+            resolveValue(collected);
+            return;
+          }
+          if (character === "" || character === "\b")
+            collected = collected.slice(0, -1);
+          else
+            collected += character;
+        }
+      };
+      input.on("data", onData);
+    });
+    process.stdout.write(`
+`);
+    return validateKey(value);
+  } finally {
+    input.setRawMode(previousRaw ?? false);
+    input.pause();
+  }
+}
+async function acquireAwKey(path, interactive = true) {
+  const fromEnvironment = process.env[AW_KEY_ENV];
+  if (fromEnvironment)
+    return { key: validateKey(fromEnvironment), source: "environment" };
+  const stored = readAwCredential(path);
+  if (stored)
+    return { key: stored, source: "stored" };
+  if (!interactive)
+    throw new Error("asset3d_api_key_required");
+  return { key: await promptAwKey(), source: "prompt" };
+}
+function writeAwCredential(pathInput, keyInput) {
+  if (!isAbsolute(pathInput))
+    throw new Error("asset3d_credential_path_invalid: absolute path required");
+  const path = resolve(pathInput);
+  const key = validateKey(keyInput);
+  const parent = dirname2(path);
+  ensurePrivateDir(parent);
+  const parentMetadata = lstatSync(parent);
+  const wrongParentOwner = typeof process.getuid === "function" && parentMetadata.uid !== process.getuid();
+  if (!parentMetadata.isDirectory() || parentMetadata.isSymbolicLink() || wrongParentOwner) {
+    throw new Error("asset3d_credential_path_invalid: parent must be an owned regular directory");
+  }
+  chmodSync(parent, 448);
+  const existed = existsSync(path);
+  if (existed)
+    readAwCredential(path);
+  const previous = existed ? readFileSync(path) : undefined;
+  const previousMode = existed ? statSync(path).mode & 511 : undefined;
+  const bytes = `${JSON.stringify({ schemaVersion: AW_CREDENTIAL_SCHEMA, provider: "aw", sandboxKey: key }, null, 2)}
+`;
+  const changed = !previous || !previous.equals(Buffer.from(bytes));
+  if (changed)
+    atomicWrite(path, bytes, 384);
+  chmodSync(path, 384);
+  let active = true;
+  return {
+    path,
+    changed,
+    commit() {
+      active = false;
+    },
+    rollback() {
+      if (!active || !changed)
+        return;
+      if (previous) {
+        atomicWrite(path, previous, previousMode ?? 384);
+        chmodSync(path, previousMode ?? 384);
+      } else {
+        unlinkSync(path);
+      }
+      active = false;
+    }
+  };
+}
+
+// extensions/asset3d/src/origins.ts
+import { domainToASCII } from "node:url";
+
+// extensions/asset3d/src/constants.ts
+import { createHash } from "node:crypto";
+var PROVIDER_RESULT_SCHEMA = "forgeax.asset3d-search-result/2.0.0";
+var PROVIDER_RECEIPT_SCHEMA = "forgeax.asset3d-search-receipt/2.0.0";
+var INSTALL_SCHEMA = "forgeax.asset3d-install/2.0.0";
+var TRANSACTION_SCHEMA = "forgeax.asset3d-transaction/2.0.0";
+var PROVENANCE_SCHEMA = "forgeax.asset3d-provenance/2.0.0";
+var MAX_JSON_BYTES = 1024 * 1024;
+var SKILL_MOUNTS = Object.freeze({
+  codex: ".agents/skills",
+  claude: ".claude/skills",
+  cursor: ".cursor/skills",
+  trae: ".trae/skills",
+  codebuddy: ".codebuddy/skills",
+  windsurf: ".codeium/windsurf/skills",
+  vscode: ".vscode/skills",
+  zcode: ".zcode/skills",
+  opencode: ".config/opencode/skills"
+});
+function sha256(value) {
+  return createHash("sha256").update(value).digest("hex");
+}
+function canonicalJson(value) {
+  if (value === null || typeof value !== "object")
+    return JSON.stringify(value);
+  if (Array.isArray(value))
+    return `[${value.map(canonicalJson).join(",")}]`;
+  return `{${Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, entry]) => `${JSON.stringify(key)}:${canonicalJson(entry)}`).join(",")}}`;
+}
+
+// extensions/asset3d/src/origins.ts
+function canonicalIpv4(host) {
+  const parts = host.split(".");
+  if (parts.length !== 4 || parts.some((part) => !/^\d{1,3}$/.test(part)))
+    return;
+  const values = parts.map(Number);
+  if (values.some((value) => value > 255))
+    throw new Error("download_origin_invalid: invalid IPv4 address");
+  return values.join(".");
+}
+function canonicalizeOrigins(inputs) {
+  if (inputs.length < 1 || inputs.length > 8) {
+    throw new Error("download_origin_count_invalid: expected 1..8 --download-origin values");
+  }
+  const values = inputs.map((input) => {
+    const lexical = /^(https?):\/\/(\[[0-9A-Fa-f:.]+\]|[^:/?#@]+):(\d{1,5})$/.exec(input);
+    if (!lexical) {
+      throw new Error("download_origin_invalid: expected exact scheme://host:port without path, query, fragment, or userinfo");
+    }
+    let parsed;
+    try {
+      parsed = new URL(input);
+    } catch {
+      throw new Error("download_origin_invalid: malformed URL");
+    }
+    if (parsed.protocol !== "http:" && parsed.protocol !== "https:")
+      throw new Error("download_origin_invalid: http or https required");
+    if (parsed.username || parsed.password || parsed.pathname !== "/" || parsed.search || parsed.hash) {
+      throw new Error("download_origin_invalid: userinfo/path/query/fragment is forbidden");
+    }
+    const port = Number(lexical[3]);
+    if (!Number.isInteger(port) || port < 1 || port > 65535)
+      throw new Error("download_origin_invalid: explicit port must be 1..65535");
+    let host = lexical[2];
+    if (host === "*" || host.includes("*"))
+      throw new Error("download_origin_invalid: wildcard host is forbidden");
+    if (host.startsWith("[") && host.endsWith("]")) {
+      const normalized = new URL(`${parsed.protocol}//${host}:${port}`).hostname;
+      host = normalized.startsWith("[") ? normalized.toLowerCase() : `[${normalized.toLowerCase()}]`;
+    } else {
+      host = canonicalIpv4(host) ?? domainToASCII(host.replace(/\.$/, "")).toLowerCase();
+      if (!host)
+        throw new Error("download_origin_invalid: host cannot be canonicalized");
+    }
+    return `${lexical[1]}://${host}:${port}`;
+  }).sort();
+  if (new Set(values).size !== values.length)
+    throw new Error("download_origin_duplicate: canonical duplicates are forbidden");
+  const compactJson = canonicalJson(values);
+  return { values, compactJson, digest: sha256(compactJson) };
+}
+
+// extensions/asset3d/src/aw-access.ts
+var AW_SERVICE_PATH = "/trpc.oasismetric.omcontentserver.http";
+var DEFAULT_AW_PUBLIC_SERVICE_ROOT = "http://lb-pl74wsqg-5wi8ujmy1fq2746r.clb.usw-tencentclb.com:8008/trpc.oasismetric.omcontentserver.http";
+function normalizeAssetLibraryServiceRoot(input) {
+  let parsed;
+  try {
+    parsed = new URL(input);
+  } catch {
+    throw new Error("asset3d_base_url_invalid");
+  }
+  if (!["http:", "https:"].includes(parsed.protocol) || parsed.username || parsed.password || parsed.search || parsed.hash) {
+    throw new Error("asset3d_base_url_invalid");
+  }
+  let path = parsed.pathname.replace(/\/+$/, "");
+  if (path.endsWith(AW_SERVICE_PATH + "/HybridSearch"))
+    path = path.slice(0, -"/HybridSearch".length);
+  else if (!path.endsWith(AW_SERVICE_PATH))
+    path += AW_SERVICE_PATH;
+  parsed.pathname = path;
+  return parsed.toString().replace(/\/$/, "");
+}
+function resolveAssetLibrarySelection(options = {}) {
+  const library = options.library || process.env.FORGEAX_ASSET_LIBRARY || "aw";
+  if (library !== "aw" && library !== "ea")
+    throw new Error("asset3d_library_invalid: expected aw or ea");
+  const base = options.baseUrl || process.env.FORGEAX_ASSET_LIBRARY_BASE_URL || (library === "aw" ? DEFAULT_AW_PUBLIC_SERVICE_ROOT : undefined);
+  if (!base)
+    throw new Error("FORGEAX_ASSET_LIBRARY_BASE_URL is required when FORGEAX_ASSET_LIBRARY=ea. Set the EA gateway URL explicitly.");
+  return { library, serviceRoot: normalizeAssetLibraryServiceRoot(base) };
+}
+function downloadOrigin(input) {
+  let url;
+  try {
+    url = new URL(input);
+  } catch {
+    throw new Error("asset3d_download_url_invalid");
+  }
+  if (!["http:", "https:"].includes(url.protocol) || url.username || url.password || url.hash) {
+    throw new Error("asset3d_download_url_invalid");
+  }
+  return `${url.protocol}//${url.hostname}:${url.port || (url.protocol === "https:" ? "443" : "80")}`;
+}
+async function boundedResponse(response, limit) {
+  if (!response.body)
+    throw new Error("asset3d_response_invalid");
+  const reader = response.body.getReader();
+  const chunks = [];
+  let size = 0;
+  try {
+    for (;; ) {
+      const part = await reader.read();
+      if (part.done)
+        break;
+      size += part.value.byteLength;
+      if (size > limit)
+        throw new Error("asset3d_response_too_large");
+      chunks.push(part.value);
+    }
+  } finally {
+    await reader.cancel().catch(() => {});
+  }
+  return Buffer.concat(chunks);
+}
+async function searchLibrary(config, query) {
+  if (!query.trim() || query.length > 200)
+    throw new Error("asset3d_query_invalid");
+  const key = readAwCredential(config.credentialFile);
+  if (!key)
+    throw new Error("asset3d_api_key_required");
+  let response;
+  try {
+    response = await fetch(normalizeAssetLibraryServiceRoot(config.serviceRoot) + "/HybridSearch", {
+      method: "POST",
+      redirect: "error",
+      signal: AbortSignal.timeout(30000),
+      headers: { "Content-Type": "application/json", "X-Sandbox-Key": key },
+      body: JSON.stringify({
+        depot_name: config.library,
+        asset_type: 1,
+        req_content_type: 0,
+        content: query,
+        similarity_score: 0,
+        page_size: 10
+      })
+    });
+  } catch {
+    throw new Error("asset3d_service_unreachable");
+  }
+  if (response.status === 401 || response.status === 403)
+    throw new Error("asset3d_access_denied");
+  if (!response.ok)
+    throw new Error(`asset3d_service_http_${response.status}`);
+  let value;
+  try {
+    value = JSON.parse((await boundedResponse(response, 1024 * 1024)).toString());
+  } catch {
+    throw new Error("asset3d_search_response_invalid");
+  }
+  if (!value || value.ret !== undefined && value.ret !== 0 || !Array.isArray(value.asset_list) || value.asset_list.length > 100) {
+    throw new Error("asset3d_search_response_invalid");
+  }
+  const seen = new Set;
+  return value.asset_list.slice(0, 10).map((asset) => {
+    if (!asset || typeof asset.id !== "string" || !/^[a-zA-Z0-9_-][a-zA-Z0-9._-]{0,127}$/.test(asset.id) || seen.has(asset.id) || typeof asset.name !== "string" || !asset.name || asset.name.length > 128 || typeof asset.res_url !== "string")
+      throw new Error("asset3d_search_response_invalid");
+    seen.add(asset.id);
+    downloadOrigin(asset.res_url);
+    const path = new URL(asset.res_url).pathname;
+    const format = String(asset.file_format || asset.format || path.split(".").pop() || "unknown").toLowerCase();
+    return { assetId: asset.id, name: asset.name, format, downloadUrl: asset.res_url };
+  });
+}
+async function checkAssetLibraryAccess(config) {
+  const candidates = await searchLibrary(config, "tree");
+  if (!candidates.length)
+    throw new Error("asset3d_access_validation_inconclusive: no download origin returned");
+  const origins = canonicalizeOrigins([...new Set(candidates.map((c) => downloadOrigin(c.downloadUrl)))]);
+  return { serviceRoot: config.serviceRoot, authentication: "sandbox-key", downloadOrigins: origins.values };
+}
+
+// extensions/asset3d/src/library.ts
+import { mkdirSync as mkdirSync3, writeFileSync as writeFileSync4 } from "node:fs";
+import { dirname as dirname4, resolve as resolve7 } from "node:path";
+
+// node_modules/fflate/esm/index.mjs
+import { createRequire } from "module";
+var require2 = createRequire("/");
+var Worker;
+try {
+  Worker = require2("worker_threads").Worker;
+} catch (e) {}
+var u8 = Uint8Array;
+var u16 = Uint16Array;
+var i32 = Int32Array;
+var fleb = new u8([0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0, 0, 0, 0]);
+var fdeb = new u8([0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13, 0, 0]);
+var clim = new u8([16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15]);
+var freb = function(eb, start) {
+  var b = new u16(31);
+  for (var i = 0;i < 31; ++i) {
+    b[i] = start += 1 << eb[i - 1];
+  }
+  var r = new i32(b[30]);
+  for (var i = 1;i < 30; ++i) {
+    for (var j = b[i];j < b[i + 1]; ++j) {
+      r[j] = j - b[i] << 5 | i;
+    }
+  }
+  return { b, r };
+};
+var _a = freb(fleb, 2);
+var fl = _a.b;
+var revfl = _a.r;
+fl[28] = 258, revfl[258] = 28;
+var _b = freb(fdeb, 0);
+var fd = _b.b;
+var revfd = _b.r;
+var rev = new u16(32768);
+for (i = 0;i < 32768; ++i) {
+  x = (i & 43690) >> 1 | (i & 21845) << 1;
+  x = (x & 52428) >> 2 | (x & 13107) << 2;
+  x = (x & 61680) >> 4 | (x & 3855) << 4;
+  rev[i] = ((x & 65280) >> 8 | (x & 255) << 8) >> 1;
+}
+var x;
+var i;
+var hMap = function(cd, mb, r) {
+  var s = cd.length;
+  var i2 = 0;
+  var l = new u16(mb);
+  for (;i2 < s; ++i2) {
+    if (cd[i2])
+      ++l[cd[i2] - 1];
+  }
+  var le = new u16(mb);
+  for (i2 = 1;i2 < mb; ++i2) {
+    le[i2] = le[i2 - 1] + l[i2 - 1] << 1;
+  }
+  var co;
+  if (r) {
+    co = new u16(1 << mb);
+    var rvb = 15 - mb;
+    for (i2 = 0;i2 < s; ++i2) {
+      if (cd[i2]) {
+        var sv = i2 << 4 | cd[i2];
+        var r_1 = mb - cd[i2];
+        var v = le[cd[i2] - 1]++ << r_1;
+        for (var m = v | (1 << r_1) - 1;v <= m; ++v) {
+          co[rev[v] >> rvb] = sv;
+        }
+      }
+    }
+  } else {
+    co = new u16(s);
+    for (i2 = 0;i2 < s; ++i2) {
+      if (cd[i2]) {
+        co[i2] = rev[le[cd[i2] - 1]++] >> 15 - cd[i2];
+      }
+    }
+  }
+  return co;
+};
+var flt = new u8(288);
+for (i = 0;i < 144; ++i)
+  flt[i] = 8;
+var i;
+for (i = 144;i < 256; ++i)
+  flt[i] = 9;
+var i;
+for (i = 256;i < 280; ++i)
+  flt[i] = 7;
+var i;
+for (i = 280;i < 288; ++i)
+  flt[i] = 8;
+var i;
+var fdt = new u8(32);
+for (i = 0;i < 32; ++i)
+  fdt[i] = 5;
+var i;
+var flrm = /* @__PURE__ */ hMap(flt, 9, 1);
+var fdrm = /* @__PURE__ */ hMap(fdt, 5, 1);
+var max = function(a) {
+  var m = a[0];
+  for (var i2 = 1;i2 < a.length; ++i2) {
+    if (a[i2] > m)
+      m = a[i2];
+  }
+  return m;
+};
+var bits = function(d, p, m) {
+  var o = p / 8 | 0;
+  return (d[o] | d[o + 1] << 8) >> (p & 7) & m;
+};
+var bits16 = function(d, p) {
+  var o = p / 8 | 0;
+  return (d[o] | d[o + 1] << 8 | d[o + 2] << 16) >> (p & 7);
+};
+var shft = function(p) {
+  return (p + 7) / 8 | 0;
+};
+var slc = function(v, s, e) {
+  if (s == null || s < 0)
+    s = 0;
+  if (e == null || e > v.length)
+    e = v.length;
+  return new u8(v.subarray(s, e));
+};
+var ec = [
+  "unexpected EOF",
+  "invalid block type",
+  "invalid length/literal",
+  "invalid distance",
+  "stream finished",
+  "no stream handler",
+  ,
+  "no callback",
+  "invalid UTF-8 data",
+  "extra field too long",
+  "date not in range 1980-2099",
+  "filename too long",
+  "stream finishing",
+  "invalid zip data"
+];
+var err = function(ind, msg, nt) {
+  var e = new Error(msg || ec[ind]);
+  e.code = ind;
+  if (Error.captureStackTrace)
+    Error.captureStackTrace(e, err);
+  if (!nt)
+    throw e;
+  return e;
+};
+var inflt = function(dat, st, buf, dict) {
+  var sl = dat.length, dl = dict ? dict.length : 0;
+  if (!sl || st.f && !st.l)
+    return buf || new u8(0);
+  var noBuf = !buf;
+  var resize = noBuf || st.i != 2;
+  var noSt = st.i;
+  if (noBuf)
+    buf = new u8(sl * 3);
+  var cbuf = function(l2) {
+    var bl = buf.length;
+    if (l2 > bl) {
+      var nbuf = new u8(Math.max(bl * 2, l2));
+      nbuf.set(buf);
+      buf = nbuf;
+    }
+  };
+  var final = st.f || 0, pos = st.p || 0, bt = st.b || 0, lm = st.l, dm = st.d, lbt = st.m, dbt = st.n;
+  var tbts = sl * 8;
+  do {
+    if (!lm) {
+      final = bits(dat, pos, 1);
+      var type = bits(dat, pos + 1, 3);
+      pos += 3;
+      if (!type) {
+        var s = shft(pos) + 4, l = dat[s - 4] | dat[s - 3] << 8, t = s + l;
+        if (t > sl) {
+          if (noSt)
+            err(0);
+          break;
+        }
+        if (resize)
+          cbuf(bt + l);
+        buf.set(dat.subarray(s, t), bt);
+        st.b = bt += l, st.p = pos = t * 8, st.f = final;
+        continue;
+      } else if (type == 1)
+        lm = flrm, dm = fdrm, lbt = 9, dbt = 5;
+      else if (type == 2) {
+        var hLit = bits(dat, pos, 31) + 257, hcLen = bits(dat, pos + 10, 15) + 4;
+        var tl = hLit + bits(dat, pos + 5, 31) + 1;
+        pos += 14;
+        var ldt = new u8(tl);
+        var clt = new u8(19);
+        for (var i2 = 0;i2 < hcLen; ++i2) {
+          clt[clim[i2]] = bits(dat, pos + i2 * 3, 7);
+        }
+        pos += hcLen * 3;
+        var clb = max(clt), clbmsk = (1 << clb) - 1;
+        var clm = hMap(clt, clb, 1);
+        for (var i2 = 0;i2 < tl; ) {
+          var r = clm[bits(dat, pos, clbmsk)];
+          pos += r & 15;
+          var s = r >> 4;
+          if (s < 16) {
+            ldt[i2++] = s;
+          } else {
+            var c = 0, n = 0;
+            if (s == 16)
+              n = 3 + bits(dat, pos, 3), pos += 2, c = ldt[i2 - 1];
+            else if (s == 17)
+              n = 3 + bits(dat, pos, 7), pos += 3;
+            else if (s == 18)
+              n = 11 + bits(dat, pos, 127), pos += 7;
+            while (n--)
+              ldt[i2++] = c;
+          }
+        }
+        var lt = ldt.subarray(0, hLit), dt = ldt.subarray(hLit);
+        lbt = max(lt);
+        dbt = max(dt);
+        lm = hMap(lt, lbt, 1);
+        dm = hMap(dt, dbt, 1);
+      } else
+        err(1);
+      if (pos > tbts) {
+        if (noSt)
+          err(0);
+        break;
+      }
+    }
+    if (resize)
+      cbuf(bt + 131072);
+    var lms = (1 << lbt) - 1, dms = (1 << dbt) - 1;
+    var lpos = pos;
+    for (;; lpos = pos) {
+      var c = lm[bits16(dat, pos) & lms], sym = c >> 4;
+      pos += c & 15;
+      if (pos > tbts) {
+        if (noSt)
+          err(0);
+        break;
+      }
+      if (!c)
+        err(2);
+      if (sym < 256)
+        buf[bt++] = sym;
+      else if (sym == 256) {
+        lpos = pos, lm = null;
+        break;
+      } else {
+        var add = sym - 254;
+        if (sym > 264) {
+          var i2 = sym - 257, b = fleb[i2];
+          add = bits(dat, pos, (1 << b) - 1) + fl[i2];
+          pos += b;
+        }
+        var d = dm[bits16(dat, pos) & dms], dsym = d >> 4;
+        if (!d)
+          err(3);
+        pos += d & 15;
+        var dt = fd[dsym];
+        if (dsym > 3) {
+          var b = fdeb[dsym];
+          dt += bits16(dat, pos) & (1 << b) - 1, pos += b;
+        }
+        if (pos > tbts) {
+          if (noSt)
+            err(0);
+          break;
+        }
+        if (resize)
+          cbuf(bt + 131072);
+        var end = bt + add;
+        if (bt < dt) {
+          var shift = dl - dt, dend = Math.min(dt, end);
+          if (shift + bt < 0)
+            err(3);
+          for (;bt < dend; ++bt)
+            buf[bt] = dict[shift + bt];
+        }
+        for (;bt < end; ++bt)
+          buf[bt] = buf[bt - dt];
+      }
+    }
+    st.l = lm, st.p = lpos, st.b = bt, st.f = final;
+    if (lm)
+      final = 1, st.m = lbt, st.d = dm, st.n = dbt;
+  } while (!final);
+  return bt != buf.length && noBuf ? slc(buf, 0, bt) : buf.subarray(0, bt);
+};
+var et = /* @__PURE__ */ new u8(0);
+var b2 = function(d, b) {
+  return d[b] | d[b + 1] << 8;
+};
+var b4 = function(d, b) {
+  return (d[b] | d[b + 1] << 8 | d[b + 2] << 16 | d[b + 3] << 24) >>> 0;
+};
+var b8 = function(d, b) {
+  return b4(d, b) + b4(d, b + 4) * 4294967296;
+};
+function inflateSync(data, opts) {
+  return inflt(data, { i: 2 }, opts && opts.out, opts && opts.dictionary);
+}
+var td = typeof TextDecoder != "undefined" && /* @__PURE__ */ new TextDecoder;
+var tds = 0;
+try {
+  td.decode(et, { stream: true });
+  tds = 1;
+} catch (e) {}
+var dutf8 = function(d) {
+  for (var r = "", i2 = 0;; ) {
+    var c = d[i2++];
+    var eb = (c > 127) + (c > 223) + (c > 239);
+    if (i2 + eb > d.length)
+      return { s: r, r: slc(d, i2 - 1) };
+    if (!eb)
+      r += String.fromCharCode(c);
+    else if (eb == 3) {
+      c = ((c & 15) << 18 | (d[i2++] & 63) << 12 | (d[i2++] & 63) << 6 | d[i2++] & 63) - 65536, r += String.fromCharCode(55296 | c >> 10, 56320 | c & 1023);
+    } else if (eb & 1)
+      r += String.fromCharCode((c & 31) << 6 | d[i2++] & 63);
+    else
+      r += String.fromCharCode((c & 15) << 12 | (d[i2++] & 63) << 6 | d[i2++] & 63);
+  }
+};
+function strFromU8(dat, latin1) {
+  if (latin1) {
+    var r = "";
+    for (var i2 = 0;i2 < dat.length; i2 += 16384)
+      r += String.fromCharCode.apply(null, dat.subarray(i2, i2 + 16384));
+    return r;
+  } else if (td) {
+    return td.decode(dat);
+  } else {
+    var _a2 = dutf8(dat), s = _a2.s, r = _a2.r;
+    if (r.length)
+      err(8);
+    return s;
+  }
+}
+var slzh = function(d, b) {
+  return b + 30 + b2(d, b + 26) + b2(d, b + 28);
+};
+var zh = function(d, b, z) {
+  var fnl = b2(d, b + 28), fn = strFromU8(d.subarray(b + 46, b + 46 + fnl), !(b2(d, b + 8) & 2048)), es = b + 46 + fnl, bs = b4(d, b + 20);
+  var _a2 = z && bs == 4294967295 ? z64e(d, es) : [bs, b4(d, b + 24), b4(d, b + 42)], sc = _a2[0], su = _a2[1], off = _a2[2];
+  return [b2(d, b + 10), sc, su, fn, es + b2(d, b + 30) + b2(d, b + 32), off];
+};
+var z64e = function(d, b) {
+  for (;b2(d, b) != 1; b += 4 + b2(d, b + 2))
+    ;
+  return [b8(d, b + 12), b8(d, b + 4), b8(d, b + 20)];
+};
+function unzipSync(data, opts) {
+  var files = {};
+  var e = data.length - 22;
+  for (;b4(data, e) != 101010256; --e) {
+    if (!e || data.length - e > 65558)
+      err(13);
+  }
+  var c = b2(data, e + 8);
+  if (!c)
+    return {};
+  var o = b4(data, e + 16);
+  var z = o == 4294967295 || c == 65535;
+  if (z) {
+    var ze = b4(data, e - 12);
+    z = b4(data, ze) == 101075792;
+    if (z) {
+      c = b4(data, ze + 32);
+      o = b4(data, ze + 48);
+    }
+  }
+  var fltr = opts && opts.filter;
+  for (var i2 = 0;i2 < c; ++i2) {
+    var _a2 = zh(data, o, z), c_2 = _a2[0], sc = _a2[1], su = _a2[2], fn = _a2[3], no = _a2[4], off = _a2[5], b = slzh(data, off);
+    o = no;
+    if (!fltr || fltr({
+      name: fn,
+      size: sc,
+      originalSize: su,
+      compression: c_2
+    })) {
+      if (!c_2)
+        files[fn] = slc(data, b, b + sc);
+      else if (c_2 == 8)
+        files[fn] = inflateSync(data.subarray(b, b + sc), { out: new u8(su) });
+      else
+        err(14, "unknown compression type " + c_2);
+    }
+  }
+  return files;
+}
+
+// extensions/asset3d/src/install.ts
+import { readFileSync as readFileSync2 } from "node:fs";
+import { resolve as resolve2 } from "node:path";
+function readAsset3dConfig(root) {
+  const bytes = readFileSync2(resolve2(root, ".forgeax/extensions/asset3d/config.json"));
+  if (bytes.length > 65536)
+    throw new Error("asset3d_config_invalid");
+  const value = JSON.parse(bytes.toString());
+  if (value.schemaVersion !== INSTALL_SCHEMA || !["aw", "ea"].includes(value.library) || typeof value.credentialFile !== "string" || !Array.isArray(value.downloadOrigins) || normalizeAssetLibraryServiceRoot(value.serviceRoot) !== value.serviceRoot || canonicalizeOrigins(value.downloadOrigins).digest !== value.originSetDigest)
+    throw new Error("asset3d_config_invalid");
+  return value;
+}
+
+// extensions/asset3d/src/schema.ts
+var ID = /^[A-Za-z0-9._-]{1,128}$/;
+var DIGEST = /^[a-f0-9]{64}$/;
+var ERROR_CODES = new Set([
+  "asset_not_found",
+  "asset_identity_missing",
+  "search_timeout",
+  "search_upstream_error",
+  "download_timeout",
+  "download_origin_rejected",
+  "download_too_large",
+  "archive_rejected",
+  "conversion_failed",
+  "digest_failed",
+  "batch_timeout",
+  "internal_error"
+]);
+var ROLES = new Set(["primary-pack", "auxiliary-pack", "primary-model", "animation", "auxiliary-model", "texture", "metadata"]);
+function exactKeys(record, allowed, field) {
+  const extras = Object.keys(record).filter((key) => !allowed.includes(key));
+  if (extras.length)
+    throw new Error(`provider_result_invalid: unknown ${field} fields`);
+}
+function safeRelativePath(value) {
+  if (typeof value !== "string" || value.length < 1 || value.length > 512 || value.startsWith("/") || value.includes("\\")) {
+    throw new Error("provider_result_invalid: manifest path must be relative POSIX");
+  }
+  const parts = value.split("/");
+  if (parts.some((part) => !part || part === "." || part === ".."))
+    throw new Error("provider_result_invalid: unsafe manifest path");
+  return value;
+}
+function number(value, min, max2, field) {
+  if (!Number.isInteger(value) || value < min || value > max2)
+    throw new Error(`provider_result_invalid: ${field}`);
+  return value;
+}
+function text(value, min, max2, field) {
+  if (typeof value !== "string" || [...value].length < min || [...value].length > max2)
+    throw new Error(`provider_result_invalid: ${field}`);
+  return value;
+}
+function aggregate(entries) {
+  const bytes = entries.map((entry) => `${entry.path}\x00${entry.bytes}\x00${entry.sha256}
+`).join("");
+  return sha256(bytes);
+}
+function parseProviderResult(input, expectedVersion, expectedOriginSetDigest) {
+  const bytes = typeof input === "string" ? Buffer.byteLength(input) : input.byteLength;
+  if (bytes > MAX_JSON_BYTES)
+    throw new Error("provider_result_too_large: stdin exceeds 1 MiB");
+  let raw;
+  try {
+    raw = JSON.parse(typeof input === "string" ? input : Buffer.from(input).toString("utf8"));
+  } catch {
+    throw new Error("provider_result_invalid: stdin is not JSON");
+  }
+  if (!raw || typeof raw !== "object" || Array.isArray(raw))
+    throw new Error("provider_result_invalid: top-level object required");
+  const root = raw;
+  exactKeys(root, ["schemaVersion", "total", "succeeded", "failed", "results", "receipt"], "top-level");
+  if (root.schemaVersion !== PROVIDER_RESULT_SCHEMA)
+    throw new Error("provider_result_invalid: schemaVersion");
+  const total = number(root.total, 1, 16, "total");
+  const succeeded = number(root.succeeded, 0, total, "succeeded");
+  const failed = number(root.failed, 0, total, "failed");
+  if (succeeded + failed !== total || !Array.isArray(root.results) || root.results.length !== total)
+    throw new Error("provider_result_invalid: counts");
+  let receipt;
+  if (root.receipt !== undefined) {
+    if (!root.receipt || typeof root.receipt !== "object" || Array.isArray(root.receipt)) {
+      throw new Error("provider_result_invalid: receipt object required");
+    }
+    const value = root.receipt;
+    exactKeys(value, ["schemaVersion", "provider", "adapterVersion", "originSetDigest"], "receipt");
+    if (value.schemaVersion !== PROVIDER_RECEIPT_SCHEMA || value.provider !== "ea-3d" || value.adapterVersion !== expectedVersion || value.originSetDigest !== expectedOriginSetDigest) {
+      throw new Error("provider_result_invalid: receipt identity");
+    }
+    receipt = {
+      schemaVersion: PROVIDER_RECEIPT_SCHEMA,
+      provider: "ea-3d",
+      adapterVersion: expectedVersion,
+      originSetDigest: expectedOriginSetDigest
+    };
+  }
+  if (succeeded > 0 && receipt === undefined)
+    throw new Error("provider_result_invalid: success receipt required");
+  const indices = new Set;
+  let okCount = 0;
+  const results = root.results.map((candidate) => {
+    if (!candidate || typeof candidate !== "object" || Array.isArray(candidate))
+      throw new Error("provider_result_invalid: result row");
+    const row = candidate;
+    const queryIndex = number(row.queryIndex, 0, total - 1, "queryIndex");
+    if (indices.has(queryIndex))
+      throw new Error("provider_result_invalid: duplicate queryIndex");
+    indices.add(queryIndex);
+    const query = text(row.query, 1, 200, "query");
+    if (row.status === "error") {
+      exactKeys(row, ["status", "queryIndex", "query", "code", "retryable", "message"], "error");
+      if (typeof row.code !== "string" || !ERROR_CODES.has(row.code) || typeof row.retryable !== "boolean")
+        throw new Error("provider_result_invalid: error row");
+      const message = text(row.message, 0, 256, "message");
+      return { status: "error", queryIndex, query, code: row.code, retryable: row.retryable, message };
+    }
+    if (row.status !== "ok")
+      throw new Error("provider_result_invalid: status");
+    const isPack = row.deliveredFormat === "pack";
+    const primaryKey = isPack ? "primaryPack" : "primaryModel";
+    const primaryRole = isPack ? "primary-pack" : "primary-model";
+    exactKeys(row, ["status", "queryIndex", "query", "provider", "providerAssetId", "assetName", "deliveredFormat", "sha256", "bytes", primaryKey, "manifest", "originSetDigest", "downloaded_to"], "success");
+    okCount++;
+    if (row.provider !== "ea-3d" || row.deliveredFormat !== "glb" && !isPack || typeof row.providerAssetId !== "string" || !ID.test(row.providerAssetId) || row.providerAssetId === "." || row.providerAssetId === "..") {
+      throw new Error("provider_result_invalid: success identity");
+    }
+    const assetName = text(row.assetName, 1, 128, "assetName");
+    const itemBytes = number(row.bytes, 1, 268435456, "bytes");
+    if (typeof row.sha256 !== "string" || !DIGEST.test(row.sha256))
+      throw new Error("provider_result_invalid: aggregate digest");
+    if (!Array.isArray(row.manifest) || row.manifest.length < 1 || row.manifest.length > 1024)
+      throw new Error("provider_result_invalid: manifest count");
+    const seen = new Set;
+    const manifest = row.manifest.map((entry) => {
+      if (!entry || typeof entry !== "object" || Array.isArray(entry))
+        throw new Error("provider_result_invalid: manifest entry");
+      const item = entry;
+      exactKeys(item, ["path", "role", "bytes", "sha256"], "manifest");
+      const path = safeRelativePath(item.path);
+      if (seen.has(path))
+        throw new Error("provider_result_invalid: duplicate manifest path");
+      seen.add(path);
+      if (typeof item.role !== "string" || !ROLES.has(item.role))
+        throw new Error("provider_result_invalid: manifest role");
+      const role = item.role;
+      const entryBytes = number(item.bytes, 1, 134217728, "manifest bytes");
+      if (typeof item.sha256 !== "string" || !DIGEST.test(item.sha256))
+        throw new Error("provider_result_invalid: manifest digest");
+      if ((role === "primary-model" || role === "animation" || role === "auxiliary-model") && !path.toLowerCase().endsWith(".glb")) {
+        throw new Error("provider_result_invalid: model entry must be GLB");
+      }
+      if ((role === "primary-pack" || role === "auxiliary-pack") && (!isPack || !/\.pack\.(json|ts)$/i.test(path))) {
+        throw new Error("provider_result_invalid: pack entry must be authored Pack");
+      }
+      if (isPack && role === "primary-model")
+        throw new Error("provider_result_invalid: multiple primary formats");
+      return { path, role, bytes: entryBytes, sha256: item.sha256 };
+    });
+    const sorted = [...manifest].sort((left, right) => Buffer.from(left.path).compare(Buffer.from(right.path)));
+    if (manifest.some((entry, index) => entry.path !== sorted[index].path))
+      throw new Error("provider_result_invalid: manifest must be UTF-8 path sorted");
+    const primary = manifest.filter((entry) => entry.role === primaryRole);
+    if (primary.length !== 1 || row[primaryKey] !== primary[0].path)
+      throw new Error("provider_result_invalid: primary model");
+    if (manifest.reduce((sum, entry) => sum + entry.bytes, 0) !== itemBytes || aggregate(manifest) !== row.sha256) {
+      throw new Error("provider_result_invalid: byte or aggregate digest mismatch");
+    }
+    if (row.originSetDigest !== expectedOriginSetDigest)
+      throw new Error("provider_result_invalid: originSetDigest identity");
+    return {
+      status: "ok",
+      queryIndex,
+      query,
+      provider: "ea-3d",
+      providerAssetId: row.providerAssetId,
+      assetName,
+      sha256: row.sha256,
+      bytes: itemBytes,
+      ...isPack ? { deliveredFormat: "pack", primaryPack: row.primaryPack } : { deliveredFormat: "glb", primaryModel: row.primaryModel },
+      manifest,
+      originSetDigest: expectedOriginSetDigest,
+      ...row.downloaded_to === undefined ? {} : { downloaded_to: row.downloaded_to }
+    };
+  });
+  if (okCount !== succeeded || total - okCount !== failed)
+    throw new Error("provider_result_invalid: status counts");
+  return { schemaVersion: PROVIDER_RESULT_SCHEMA, total, succeeded, failed, results, ...receipt ? { receipt } : {} };
+}
+
+// extensions/asset3d/src/transaction.ts
+import { spawnSync } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import {
+  closeSync as closeSync2,
+  constants,
+  cpSync,
+  existsSync as existsSync4,
+  fstatSync,
+  lstatSync as lstatSync5,
+  mkdirSync as mkdirSync2,
+  openSync as openSync2,
+  readFileSync as readFileSync6,
+  readdirSync as readdirSync2,
+  realpathSync as realpathSync4,
+  renameSync as renameSync2,
+  rmSync as rmSync2,
+  statSync as statSync2,
+  unlinkSync as unlinkSync2,
+  writeFileSync as writeFileSync3
+} from "node:fs";
+import { isAbsolute as isAbsolute5, relative as relative4, resolve as resolve6, sep as sep4 } from "node:path";
+
+// src/engine/release.ts
+import { existsSync as existsSync3, lstatSync as lstatSync3, readFileSync as readFileSync4, realpathSync as realpathSync2 } from "node:fs";
+import { isAbsolute as isAbsolute3, relative as relative2, resolve as resolve4, sep as sep2 } from "node:path";
+
+// src/engine/constants.ts
+var ENGINE_VERSION = "0.1.26";
+var ENGINE_COMMIT = "f3d0db12405e168e4204e32a9cde32e0df8d87ae";
+var ENGINE_SDK_PACKAGE = "@forgeax/engine-sdk";
+var PNPM_VERSION = "11.7.0";
+
+// src/engine/carrier.ts
+import {
+  chmodSync as chmodSync2,
+  existsSync as existsSync2,
+  lstatSync as lstatSync2,
+  mkdtempSync,
+  readFileSync as readFileSync3,
+  readdirSync,
+  realpathSync,
+  rmSync,
+  writeFileSync as writeFileSync2
+} from "node:fs";
+import { createRequire as createRequire2 } from "node:module";
+import { basename, delimiter, dirname as dirname3, isAbsolute as isAbsolute2, relative, resolve as resolve3, sep } from "node:path";
+import { fileURLToPath } from "node:url";
+var SDK_MANIFEST_SCHEMA = "1.7.0";
+var SDK_CLI_RELATIVE = ["bin", "forgeax.mjs"];
+function packageJson(path) {
+  try {
+    const value = JSON.parse(readFileSync3(path, "utf8"));
+    if (value === null || typeof value !== "object" || Array.isArray(value))
+      throw new Error("not-an-object");
+    return value;
+  } catch (error) {
+    throw new Error(`engine_sdk_manifest_invalid: cannot read ${path}: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+function confined(root, candidate) {
+  const rel = relative(root, candidate);
+  return rel === "" || rel !== ".." && !rel.startsWith(`..${sep}`) && !isAbsolute2(rel);
+}
+function canonicalRegularFile(path, code, root) {
+  if (!existsSync2(path) || !lstatSync2(path).isFile())
+    throw new Error(`${code}: ${path}`);
+  const canonical = realpathSync(path);
+  if (!confined(root, canonical))
+    throw new Error(`${code}_escape: ${canonical}`);
+  return canonical;
+}
+function pluginRootFromModule() {
+  let cursor = resolve3(dirname3(fileURLToPath(import.meta.url)));
+  for (;; ) {
+    const manifestPath = resolve3(cursor, "package.json");
+    try {
+      if (packageJson(manifestPath).name === "@forgeax/game")
+        return realpathSync(cursor);
+    } catch {}
+    const parent = dirname3(cursor);
+    if (parent === cursor)
+      throw new Error("engine_sdk_plugin_missing: cannot locate @forgeax/game package root");
+    cursor = parent;
+  }
+}
+function manifestFromEntry(entry, name) {
+  let cursor = resolve3(dirname3(entry));
+  for (;; ) {
+    const manifestPath = resolve3(cursor, "package.json");
+    try {
+      if (packageJson(manifestPath).name === name)
+        return realpathSync(manifestPath);
+    } catch {}
+    const parent = dirname3(cursor);
+    if (parent === cursor)
+      throw new Error(`engine_sdk_dependency_invalid: ${name} package.json was not found`);
+    cursor = parent;
+  }
+}
+function installationRoot(pluginRoot) {
+  let cursor = pluginRoot;
+  let found;
+  for (;; ) {
+    if (basename(cursor) === "node_modules")
+      found = cursor;
+    const parent = dirname3(cursor);
+    if (parent === cursor)
+      break;
+    cursor = parent;
+  }
+  if (found === undefined) {
+    throw new Error(`engine_sdk_install_root_missing: ${pluginRoot} is not inside a node_modules installation`);
+  }
+  return realpathSync(found);
+}
+function resolveDependency(pluginRoot, installRoot, name, missingCode) {
+  const packageRequire = createRequire2(resolve3(pluginRoot, "package.json"));
+  let manifestPath;
+  try {
+    try {
+      manifestPath = packageRequire.resolve(`${name}/package.json`, { paths: [pluginRoot] });
+    } catch {
+      manifestPath = manifestFromEntry(packageRequire.resolve(name, { paths: [pluginRoot] }), name);
+    }
+  } catch (error) {
+    throw new Error(`${missingCode}: ${name} is not installed in the Game Plugin dependency graph${error instanceof Error ? ` (${error.message})` : ""}`);
+  }
+  const canonicalManifest = realpathSync(manifestPath);
+  const root = realpathSync(dirname3(canonicalManifest));
+  if (!confined(installRoot, pluginRoot) || !confined(installRoot, root)) {
+    throw new Error(`engine_sdk_dependency_escape: ${name} resolves outside the Game Plugin installation root`);
+  }
+  return { root, manifest: packageJson(canonicalManifest) };
+}
+function sdkManifest(path) {
+  const value = packageJson(path);
+  const packageEntries = Array.isArray(value.packages) ? value.packages : [];
+  const requiredPackages = new Map;
+  const packageNames = new Set;
+  let packagesValid = Array.isArray(value.packages);
+  for (const entry of packageEntries) {
+    if (entry === null || typeof entry !== "object" || Array.isArray(entry)) {
+      packagesValid = false;
+      continue;
+    }
+    const name = entry.name;
+    const version = entry.version;
+    if (typeof name !== "string" || typeof version !== "string" || packageNames.has(name)) {
+      packagesValid = false;
+    } else {
+      packageNames.add(name);
+      requiredPackages.set(name, version);
+    }
+  }
+  if (!packagesValid || value.schemaVersion !== SDK_MANIFEST_SCHEMA || value.sdkVersion !== ENGINE_VERSION || value.engineCommit !== ENGINE_COMMIT || value.requirements?.pnpm !== PNPM_VERSION || requiredPackages.get("@forgeax/engine") !== ENGINE_VERSION || requiredPackages.get("@forgeax/engine-devkit") !== ENGINE_VERSION) {
+    throw new Error("engine_sdk_manifest_mismatch: carrier does not identify the approved Engine/DevKit/pnpm set");
+  }
+  return value;
+}
+function packageBin(manifest, name) {
+  if (typeof manifest.bin === "string")
+    return manifest.bin;
+  if (manifest.bin !== null && typeof manifest.bin === "object") {
+    const value = manifest.bin[name];
+    if (typeof value === "string" && value.length > 0)
+      return value;
+  }
+  throw new Error(`engine_sdk_cli_invalid: ${name} package does not declare a ${name} binary`);
+}
+function resolveGamePluginCarrier(options = {}) {
+  const configuredRoot = resolve3(options.pluginRoot ?? pluginRootFromModule());
+  let pluginRoot;
+  try {
+    pluginRoot = realpathSync(configuredRoot);
+  } catch (error) {
+    throw new Error(`engine_sdk_plugin_missing: cannot read Game Plugin root ${configuredRoot}${error instanceof Error ? ` (${error.message})` : ""}`);
+  }
+  const plugin = packageJson(resolve3(pluginRoot, "package.json"));
+  const installRoot = installationRoot(pluginRoot);
+  if (!confined(installRoot, pluginRoot)) {
+    throw new Error(`engine_sdk_plugin_escape: ${pluginRoot} is outside its installation root`);
+  }
+  if (plugin.name !== "@forgeax/game")
+    throw new Error(`engine_sdk_plugin_invalid: ${pluginRoot}`);
+  if (plugin.dependencies?.[ENGINE_SDK_PACKAGE] !== ENGINE_VERSION) {
+    throw new Error(`engine_sdk_dependency_mismatch: ${ENGINE_SDK_PACKAGE} must be ${ENGINE_VERSION}`);
+  }
+  if (plugin.dependencies?.pnpm !== PNPM_VERSION) {
+    throw new Error(`pnpm_dependency_mismatch: pnpm must be ${PNPM_VERSION}`);
+  }
+  const carrier = resolveDependency(pluginRoot, installRoot, ENGINE_SDK_PACKAGE, "engine_sdk_carrier_missing");
+  if (carrier.manifest.name !== ENGINE_SDK_PACKAGE || carrier.manifest.version !== ENGINE_VERSION) {
+    throw new Error(`engine_sdk_carrier_mismatch: installed SDK carrier must be ${ENGINE_SDK_PACKAGE}@${ENGINE_VERSION}`);
+  }
+  const sdkRoot = resolve3(carrier.root, "sdk");
+  if (!existsSync2(sdkRoot) || !lstatSync2(sdkRoot).isDirectory()) {
+    throw new Error(`engine_sdk_root_missing: ${sdkRoot}`);
+  }
+  const canonicalSdkRoot = realpathSync(sdkRoot);
+  if (!confined(carrier.root, canonicalSdkRoot))
+    throw new Error("engine_sdk_root_escape: SDK root escaped carrier");
+  const manifest = sdkManifest(resolve3(canonicalSdkRoot, "sdk-manifest.json"));
+  const cliPath = canonicalRegularFile(resolve3(canonicalSdkRoot, ...SDK_CLI_RELATIVE), "engine_sdk_cli_invalid", canonicalSdkRoot);
+  const pnpm = resolveDependency(pluginRoot, installRoot, "pnpm", "pnpm_missing");
+  if (pnpm.manifest.name !== "pnpm" || pnpm.manifest.version !== PNPM_VERSION) {
+    throw new Error(`pnpm_version_mismatch: installed pnpm must be ${PNPM_VERSION}`);
+  }
+  const pnpmCliPath = canonicalRegularFile(resolve3(pnpm.root, packageBin(pnpm.manifest, "pnpm")), "pnpm_cli_invalid", pnpm.root);
+  return {
+    pluginRoot,
+    root: carrier.root,
+    sdkRoot: canonicalSdkRoot,
+    cliPath,
+    pnpmRoot: pnpm.root,
+    pnpmCliPath,
+    sdkManifest: manifest
+  };
+}
+
+// src/engine/release.ts
+function readManifest(path) {
+  let value;
+  try {
+    value = JSON.parse(readFileSync4(path, "utf8"));
+  } catch (error) {
+    throw new Error(`engine_release_manifest_invalid: cannot read ${path}: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error(`engine_release_manifest_invalid: ${path} is not a JSON object`);
+  }
+  return value;
+}
+function confined2(root, candidate) {
+  const rel = relative2(root, candidate);
+  return rel === "" || rel !== ".." && !rel.startsWith(`..${sep2}`) && !isAbsolute3(rel);
+}
+function exactPackage(root, name) {
+  const parts = name.slice(1).split("/");
+  const packageRoot = resolve4(root, "node_modules", `@${parts[0]}`, parts[1]);
+  const manifestPath = resolve4(packageRoot, "package.json");
+  if (!existsSync3(manifestPath) || !lstatSync3(manifestPath).isFile()) {
+    throw new Error(`engine_release_missing: ${name} is not installed under ${root}`);
+  }
+  const canonicalRoot = realpathSync2(packageRoot);
+  const canonicalModules = realpathSync2(resolve4(root, "node_modules"));
+  if (!confined2(canonicalModules, canonicalRoot)) {
+    throw new Error(`engine_release_escape: ${name} resolves outside the game node_modules tree`);
+  }
+  return { root: canonicalRoot, manifest: readManifest(realpathSync2(manifestPath)) };
+}
+function resolveEngineRelease(gameRoot, options = {}) {
+  const canonicalGameRoot = realpathSync2(resolve4(gameRoot));
+  const gameManifest = readManifest(resolve4(canonicalGameRoot, "package.json"));
+  const declared = gameManifest.dependencies?.["@forgeax/engine"];
+  if (declared !== ENGINE_VERSION) {
+    throw new Error(`engine_release_mismatch: game declares @forgeax/engine=${String(declared)}, expected ${ENGINE_VERSION}`);
+  }
+  const engine = exactPackage(canonicalGameRoot, "@forgeax/engine");
+  if (engine.manifest.name !== "@forgeax/engine" || engine.manifest.version !== ENGINE_VERSION) {
+    throw new Error(`engine_release_mismatch: installed Engine must be @forgeax/engine@${ENGINE_VERSION} from ${ENGINE_COMMIT}`);
+  }
+  const carrier = resolveGamePluginCarrier(options);
+  const carrierCommit = carrier.sdkManifest.engineCommit;
+  if (carrierCommit !== ENGINE_COMMIT) {
+    throw new Error(`engine_release_mismatch: SDK carrier does not identify Engine commit ${ENGINE_COMMIT}`);
+  }
+  const declaredCommit = engine.manifest.forgeax?.engineCommit;
+  if (declaredCommit !== undefined && declaredCommit !== carrierCommit) {
+    throw new Error(`engine_release_mismatch: installed Engine declares ${String(declaredCommit)}, expected ${String(carrierCommit)}`);
+  }
+  const cliPath = resolve4(engine.root, "dist", "bin", "forgeax.mjs");
+  if (!existsSync3(cliPath) || !lstatSync3(cliPath).isFile()) {
+    throw new Error(`engine_cli_missing: ${cliPath}`);
+  }
+  const canonicalCli = realpathSync2(cliPath);
+  if (!confined2(engine.root, canonicalCli)) {
+    throw new Error("engine_cli_escape: Engine CLI resolves outside @forgeax/engine");
+  }
+  return {
+    gameRoot: canonicalGameRoot,
+    packageRoot: engine.root,
+    cliPath: canonicalCli,
+    carrierRoot: carrier.root,
+    version: ENGINE_VERSION,
+    commit: ENGINE_COMMIT
+  };
+}
+
+// src/run/engine-preview.ts
+var ENVELOPE_LIMIT = 1024 * 1024;
+var LOG_LIMIT = 8 * 1024 * 1024;
+var trackedStates = new Map;
+var liveChildren = new Map;
+var directChildren = new Set;
+function parseEnvelope(stdout, command) {
+  if (Buffer.byteLength(stdout, "utf8") > ENVELOPE_LIMIT + 1) {
+    throw new Error(`${command}_envelope_too_large`);
+  }
+  const lines = stdout.split(/\r?\n/).filter((line) => line.trim().length > 0);
+  let envelope;
+  let envelopeIndex = -1;
+  for (const [index, line] of lines.entries()) {
+    let parsed;
+    try {
+      parsed = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+      throw new Error(`${command}_envelope_invalid: unexpected JSON frame`);
+    }
+    if (envelope !== undefined)
+      throw new Error(`${command}_envelope_invalid: multiple JSON frames`);
+    envelope = parsed;
+    envelopeIndex = index;
+  }
+  if (envelope === undefined)
+    throw new Error(`${command}_envelope_invalid: JSON frame is missing`);
+  if (envelopeIndex !== lines.length - 1) {
+    throw new Error(`${command}_envelope_invalid: diagnostics after JSON frame`);
+  }
+  if (envelope.schemaVersion !== "1.0.0" || envelope.command !== command || typeof envelope.ok !== "boolean") {
+    throw new Error(`${command}_envelope_invalid: wrong schema or command`);
+  }
+  if (!envelope.ok) {
+    const error = envelope.error && typeof envelope.error === "object" ? JSON.stringify(envelope.error) : "unknown Engine failure";
+    throw new Error(`${command}_failed: ${error}`);
+  }
+  return envelope;
+}
+
+// extensions/asset3d/src/pack-readback.ts
+import { lstatSync as lstatSync4, readFileSync as readFileSync5, realpathSync as realpathSync3 } from "node:fs";
+import { isAbsolute as isAbsolute4, relative as relative3, resolve as resolve5, sep as sep3 } from "node:path";
+var UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
+function object(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    throw new Error("engine_pack_readback_invalid");
+  return value;
+}
+function readPackBuildCatalog(projectRoot, sourcePaths, buildValue) {
+  const build = object(buildValue);
+  const runtime = object(build.runtime);
+  if (build.schemaVersion !== "1.0.0" || !Array.isArray(build.artifacts) || build.artifacts.length > 1e4) {
+    throw new Error("engine_pack_build_manifest_invalid");
+  }
+  const dist = resolve5(projectRoot, "dist");
+  const canonicalDist = realpathSync3(dist);
+  if (canonicalDist !== resolve5(realpathSync3(projectRoot), "dist") || lstatSync4(dist).isSymbolicLink()) {
+    throw new Error("engine_pack_build_path_escape");
+  }
+  const artifacts = new Map;
+  let total = 0;
+  for (const raw of build.artifacts) {
+    const entry = object(raw);
+    const path = safeRelativePath(entry.path);
+    if (artifacts.has(path) || !Number.isSafeInteger(entry.bytes) || entry.bytes < 0 || entry.bytes > 256 * 1024 * 1024 || typeof entry.sha256 !== "string" || !/^[a-f0-9]{64}$/.test(entry.sha256)) {
+      throw new Error("engine_pack_build_manifest_invalid");
+    }
+    total += entry.bytes;
+    if (total > 1024 * 1024 * 1024)
+      throw new Error("engine_pack_build_too_large");
+    const file = resolve5(dist, path);
+    const rel = relative3(canonicalDist, realpathSync3(file));
+    if (isAbsolute4(rel) || rel === ".." || rel.startsWith(`..${sep3}`))
+      throw new Error("engine_pack_build_path_escape");
+    const stat = lstatSync4(file);
+    if (!stat.isFile() || stat.isSymbolicLink() || stat.size !== entry.bytes)
+      throw new Error("engine_pack_build_file_invalid");
+    const bytes = readFileSync5(file);
+    if (sha256(bytes) !== entry.sha256)
+      throw new Error("engine_pack_build_digest_mismatch");
+    artifacts.set(path, path.endsWith(".json") ? bytes : Buffer.alloc(0));
+  }
+  const indexPath = safeRelativePath(runtime.packIndexUrl);
+  const indexBytes = artifacts.get(indexPath);
+  if (!indexBytes || indexBytes.length > 16 * 1024 * 1024)
+    throw new Error("engine_pack_catalog_missing");
+  const index = JSON.parse(indexBytes.toString("utf8"));
+  if (!Array.isArray(index))
+    throw new Error("engine_pack_catalog_invalid");
+  const sources = new Set(sourcePaths);
+  const rows = [];
+  const seen = new Set;
+  const inspect = [];
+  for (const raw of index) {
+    const row = object(raw);
+    if (typeof row.sourcePath !== "string" || !sources.has(row.sourcePath))
+      continue;
+    if (typeof row.guid !== "string" || !UUID.test(row.guid) || seen.has(row.guid) || typeof row.kind !== "string" || typeof row.packageUrl !== "string" || !row.packageUrl.startsWith("/") || row.packageUrl.startsWith("//")) {
+      throw new Error("engine_pack_catalog_invalid");
+    }
+    seen.add(row.guid);
+    const packagePath = safeRelativePath(row.packageUrl.slice(1));
+    const bytes = artifacts.get(packagePath);
+    if (!bytes || bytes.length > 16 * 1024 * 1024)
+      throw new Error("engine_pack_product_missing");
+    const pack = object(JSON.parse(bytes.toString("utf8")));
+    if (!Array.isArray(pack.assets))
+      throw new Error("engine_pack_product_invalid");
+    const matches = pack.assets.map(object).filter((asset) => asset.guid === row.guid && asset.kind === row.kind);
+    if (matches.length !== 1)
+      throw new Error("engine_pack_product_guid_missing");
+    rows.push({
+      guid: row.guid,
+      kind: row.kind,
+      source: row.sourcePath,
+      sourcePath: row.sourcePath,
+      ...typeof row.name === "string" ? { name: row.name } : {},
+      packageUrl: row.packageUrl
+    });
+    inspect.push({ guid: row.guid, kind: row.kind, packagePath, packageSha256: sha256(bytes), verified: true });
+  }
+  if (!rows.some((row) => row.kind === "scene" || row.kind === "mesh"))
+    throw new Error("engine_pack_readback_missing_renderable");
+  return {
+    authority: "engine-build-catalog",
+    verify: { artifacts: artifacts.size, bytes: total, catalogSha256: sha256(indexBytes) },
+    list: rows,
+    rows,
+    inspect
+  };
+}
+
+// extensions/asset3d/src/transaction.ts
+function confined3(root, candidate) {
+  const rel = relative4(root, candidate);
+  return rel === "" || !isAbsolute5(rel) && rel !== ".." && !rel.startsWith(`..${sep4}`);
+}
+function forgeaxRoot(projectRoot) {
+  return resolve6(projectRoot, ".forgeax/extensions/asset3d/data");
+}
+function journalPath(projectRoot, execution) {
+  return resolve6(forgeaxRoot(projectRoot), "asset3d-transactions", `${execution}.json`);
+}
+function providerResultPath(projectRoot, execution) {
+  return resolve6(forgeaxRoot(projectRoot), "asset3d-results", `${execution}.json`);
+}
+var readInstall = readAsset3dConfig;
+function readJournal(projectRoot, execution) {
+  if (!/^[0-9a-f-]{36}$/.test(execution))
+    throw new Error("asset3d_execution_invalid");
+  let journal;
+  try {
+    journal = JSON.parse(readFileSync6(journalPath(projectRoot, execution), "utf8"));
+  } catch {
+    throw new Error("asset3d_execution_not_found");
+  }
+  if (journal.schemaVersion !== TRANSACTION_SCHEMA || journal.execution !== execution)
+    throw new Error("asset3d_journal_invalid");
+  return journal;
+}
+function updateJournal(projectRoot, journal, patch) {
+  const next = { ...journal, ...patch };
+  atomicWrite(journalPath(projectRoot, journal.execution), `${JSON.stringify(next, null, 2)}
+`);
+  return next;
+}
+function beginAsset3d(projectRootInput, queries, options = {}) {
+  const projectRoot = realpathSync4(projectRootInput);
+  if (queries.length < 1 || queries.length > 16 || queries.some((query) => [...query].length < 1 || [...query].length > 200)) {
+    throw new Error("asset3d_queries_invalid: expected 1..16 queries of 1..200 characters");
+  }
+  const install = readInstall(projectRoot);
+  const release = resolveEngineRelease(projectRoot, options.carrierPluginRoot === undefined ? {} : { pluginRoot: options.carrierPluginRoot });
+  const execution = randomUUID();
+  const relativeOutput = `workspace/asset3d/${execution}`;
+  const quarantine = resolve6(projectRoot, ".forgeax/extensions/asset3d/data", "asset3d-quarantine");
+  const allowedQuarantineRoot = resolve6(quarantine, relativeOutput);
+  ensurePrivateDir(resolve6(projectRoot, ".forgeax/extensions/asset3d/data", "asset3d-transactions"));
+  ensurePrivateDir(allowedQuarantineRoot);
+  const journal = {
+    schemaVersion: TRANSACTION_SCHEMA,
+    execution,
+    queryDigest: sha256(canonicalJson(queries)),
+    adapterVersion: install.adapterVersion,
+    engineVersion: release.version,
+    engineCommit: release.commit,
+    allowedQuarantineRoot,
+    requestedCount: queries.length,
+    createdAt: new Date().toISOString(),
+    state: "begun"
+  };
+  atomicWrite(journalPath(projectRoot, execution), `${JSON.stringify(journal, null, 2)}
+`);
+  return { execution, output_dir: relativeOutput };
+}
+function asset3dSearchOutputDir(projectRootInput, execution, queries) {
+  const projectRoot = realpathSync4(projectRootInput);
+  const journal = readJournal(projectRoot, execution);
+  if (journal.state !== "begun") {
+    throw new Error(`asset3d_execution_state_invalid: ${journal.state}`);
+  }
+  if (queries.length !== journal.requestedCount || sha256(canonicalJson(queries)) !== journal.queryDigest) {
+    throw new Error("asset3d_search_query_identity_mismatch");
+  }
+  const outputDir = `workspace/asset3d/${execution}`;
+  const expectedRoot = resolve6(forgeaxRoot(projectRoot), "asset3d-quarantine", outputDir);
+  if (journal.allowedQuarantineRoot !== expectedRoot || !existsSync4(expectedRoot) || realpathSync4(expectedRoot) !== expectedRoot) {
+    throw new Error("asset3d_search_output_identity_mismatch");
+  }
+  return outputDir;
+}
+function recordAsset3dProviderResult(projectRootInput, execution, providerResult) {
+  const projectRoot = realpathSync4(projectRootInput);
+  const journal = readJournal(projectRoot, execution);
+  if (journal.state !== "begun") {
+    throw new Error(`asset3d_execution_state_invalid: ${journal.state}`);
+  }
+  const bytes = Buffer.byteLength(providerResult);
+  if (bytes < 1 || bytes > MAX_JSON_BYTES) {
+    throw new Error("provider_result_too_large: expected 1 byte..1 MiB");
+  }
+  ensurePrivateDir(resolve6(forgeaxRoot(projectRoot), "asset3d-results"));
+  atomicWrite(providerResultPath(projectRoot, execution), providerResult, 384);
+  updateJournal(projectRoot, journal, { state: "provider_complete" });
+}
+function fileBytesChecked(root, entry) {
+  const source = resolve6(root, entry.path);
+  if (!confined3(root, source))
+    throw new Error("asset_manifest_escape");
+  const canonicalRoot = realpathSync4(root);
+  const canonicalSource = realpathSync4(source);
+  if (!confined3(canonicalRoot, canonicalSource))
+    throw new Error("asset_manifest_escape");
+  const before = lstatSync5(source);
+  if (!before.isFile() || before.isSymbolicLink())
+    throw new Error("asset_manifest_not_regular");
+  const fd2 = openSync2(source, constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0));
+  try {
+    const opened = fstatSync(fd2);
+    if (!opened.isFile() || opened.size !== entry.bytes)
+      throw new Error("asset_manifest_bytes_mismatch");
+    const bytes = readFileSync6(fd2);
+    if (sha256(bytes) !== entry.sha256)
+      throw new Error("asset_manifest_digest_mismatch");
+    return bytes;
+  } finally {
+    closeSync2(fd2);
+  }
+}
+function acquireLock(projectRoot, assetId, timeoutMs) {
+  const root = resolve6(forgeaxRoot(projectRoot), "asset3d-locks");
+  ensurePrivateDir(root);
+  const path = resolve6(root, `${assetId}.lock`);
+  const token = randomUUID();
+  const deadline = Date.now() + timeoutMs;
+  for (;; ) {
+    try {
+      const fd2 = openSync2(path, "wx", 384);
+      writeFileSync3(fd2, `${JSON.stringify({ token, pid: process.pid, acquiredAt: new Date().toISOString() })}
+`);
+      closeSync2(fd2);
+      return () => {
+        try {
+          const current = JSON.parse(readFileSync6(path, "utf8"));
+          if (current.token === token)
+            unlinkSync2(path);
+        } catch {}
+      };
+    } catch (error) {
+      if (error.code !== "EEXIST")
+        throw error;
+      if (Date.now() >= deadline)
+        throw new Error("asset_busy");
+      Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, Math.min(100, deadline - Date.now()));
+    }
+  }
+}
+function engineCommand(projectRoot, args, carrierPluginRoot) {
+  const release = resolveEngineRelease(projectRoot, carrierPluginRoot === undefined ? {} : { pluginRoot: carrierPluginRoot });
+  const result = spawnSync(process.execPath, [release.cliPath, ...args], {
+    cwd: projectRoot,
+    encoding: "utf8",
+    maxBuffer: 1024 * 1024 + 1,
+    timeout: 150000
+  });
+  const stdout = result.stdout ?? "";
+  if (Buffer.byteLength(stdout) > 1024 * 1024)
+    throw new Error("engine_envelope_too_large");
+  const lines = stdout.split(`
+`).filter((line) => line.length > 0);
+  if (lines.length !== 1 || !stdout.endsWith(`
+`))
+    throw new Error("engine_terminal_envelope_invalid");
+  let envelope;
+  try {
+    envelope = JSON.parse(lines[0]);
+  } catch {
+    throw new Error("engine_terminal_envelope_invalid");
+  }
+  if (envelope.schemaVersion !== "1.0.0" || typeof envelope.command !== "string" || typeof envelope.ok !== "boolean") {
+    throw new Error("engine_terminal_envelope_invalid");
+  }
+  if (result.status !== 0 || envelope.ok !== true) {
+    throw new Error(`engine_${String(envelope.command).replace(".", "_")}_failed:${canonicalJson(envelope.error ?? { exitCode: result.status })}`);
+  }
+  return envelope;
+}
+function engineAddedRows(projectRoot, asset) {
+  let subAssets = asset.subAssets;
+  if (!Array.isArray(subAssets)) {
+    if (typeof asset.metaPath !== "string")
+      throw new Error("engine_readback_missing_meta");
+    const metaPath = resolve6(projectRoot, asset.metaPath);
+    if (!confined3(projectRoot, metaPath))
+      throw new Error("engine_readback_meta_escape");
+    const canonical = realpathSync4(metaPath);
+    const info = lstatSync5(metaPath);
+    if (!confined3(projectRoot, canonical) || !info.isFile() || info.isSymbolicLink()) {
+      throw new Error("engine_readback_meta_invalid");
+    }
+    let meta;
+    try {
+      meta = JSON.parse(readFileSync6(metaPath, "utf8"));
+    } catch {
+      throw new Error("engine_readback_meta_invalid");
+    }
+    if (!Array.isArray(meta.subAssets))
+      throw new Error("engine_readback_missing_subassets");
+    subAssets = meta.subAssets.filter((row) => row !== null && typeof row === "object" && !Array.isArray(row));
+  }
+  const projectPath = (value) => {
+    if (typeof value !== "string")
+      return value;
+    const absolute = resolve6(projectRoot, value);
+    if (!confined3(projectRoot, absolute))
+      throw new Error("engine_readback_path_escape");
+    return relative4(projectRoot, absolute).split(sep4).join("/");
+  };
+  return subAssets.map((row) => ({ source: projectPath(asset.source), metaPath: projectPath(asset.metaPath), reused: asset.reused, ...row }));
+}
+function engineReadback(projectRoot, assetRelative, add, carrierPluginRoot) {
+  const verify = engineCommand(projectRoot, ["asset", "verify", "--json"], carrierPluginRoot);
+  const list = engineCommand(projectRoot, ["asset", "list", "--json"], carrierPluginRoot);
+  const addAssets = add?.value?.assets ?? [];
+  const rows = addAssets.flatMap((asset) => engineAddedRows(projectRoot, asset));
+  const guids = [...new Set(rows.flatMap((row) => typeof row.guid === "string" ? [row.guid] : []))];
+  if (add && guids.length === 0)
+    throw new Error("engine_readback_missing_guid");
+  const inspect = guids.map((guid) => engineCommand(projectRoot, ["asset", "inspect", guid, "--json"], carrierPluginRoot).value);
+  const listed = Array.isArray(list.value) ? list.value : Array.isArray(list.value?.assets) ? list.value.assets : [];
+  for (const guid of guids)
+    if (!listed.some((entry) => entry.guid === guid))
+      throw new Error("engine_catalog_readback_missing");
+  return { ...add ? { add: add.value } : {}, verify: verify.value, list: listed, inspect, rows };
+}
+function packReadback(projectRoot, item, carrierPluginRoot) {
+  const release = resolveEngineRelease(projectRoot, carrierPluginRoot === undefined ? {} : { pluginRoot: carrierPluginRoot });
+  const result = spawnSync(process.execPath, [release.cliPath, "build", "--json"], {
+    cwd: projectRoot,
+    encoding: "utf8",
+    timeout: 150000,
+    maxBuffer: 8 * 1024 * 1024
+  });
+  if (result.error || result.status !== 0)
+    throw new Error("engine_pack_build_failed");
+  const envelope = parseEnvelope(result.stdout, "build");
+  const prefix = `assets/3d/ea-3d/${item.providerAssetId}/`;
+  return readPackBuildCatalog(projectRoot, item.manifest.map((entry) => prefix + entry.path), envelope.value);
+}
+function priorProvenance(destination) {
+  try {
+    return JSON.parse(readFileSync6(resolve6(destination, ".forgeax-asset.json"), "utf8"));
+  } catch {
+    return;
+  }
+}
+function liveFilesMatch(destination, item) {
+  return item.manifest.every((entry) => {
+    const path = resolve6(destination, entry.path);
+    try {
+      return confined3(destination, path) && statSync2(path).isFile() && statSync2(path).size === entry.bytes && sha256(readFileSync6(path)) === entry.sha256;
+    } catch {
+      return false;
+    }
+  });
+}
+function quarantineFiles(root, directory = root) {
+  const files = [];
+  for (const name of readdirSync2(directory)) {
+    const path = resolve6(directory, name);
+    const info = lstatSync5(path);
+    if (info.isSymbolicLink())
+      throw new Error("asset_quarantine_symlink_rejected");
+    if (info.isDirectory())
+      files.push(...quarantineFiles(root, path));
+    else if (info.isFile())
+      files.push(relative4(root, path).split(sep4).join("/"));
+    else
+      throw new Error("asset_quarantine_special_file_rejected");
+  }
+  return files;
+}
+function validateQuarantine(journal, items) {
+  const root = realpathSync4(journal.allowedQuarantineRoot);
+  const expected = items.flatMap((item) => item.manifest.map((entry) => entry.path)).sort();
+  if (new Set(expected).size !== expected.length)
+    throw new Error("provider_result_invalid: cross-item manifest collision");
+  const actual = quarantineFiles(root).sort();
+  if (canonicalJson(actual) !== canonicalJson(expected))
+    throw new Error("asset_quarantine_undeclared_file");
+}
+function stageItem(projectRoot, journal, item, destination, prior) {
+  const root = realpathSync4(journal.allowedQuarantineRoot);
+  const stageRoot = resolve6(forgeaxRoot(projectRoot), "asset3d-staging", journal.execution, item.providerAssetId);
+  rmSync2(stageRoot, { recursive: true, force: true });
+  ensurePrivateDir(resolve6(stageRoot, ".."));
+  if (existsSync4(destination))
+    cpSync(destination, stageRoot, { recursive: true, errorOnExist: true, force: false });
+  else
+    ensurePrivateDir(stageRoot);
+  const nextPaths = new Set(item.manifest.map((entry) => entry.path));
+  const previousFiles = Array.isArray(prior?.files) ? prior.files : [];
+  for (const previous of previousFiles) {
+    if (typeof previous.relativePath !== "string" || nextPaths.has(previous.relativePath))
+      continue;
+    const stale = resolve6(stageRoot, previous.relativePath);
+    if (!confined3(stageRoot, stale))
+      throw new Error("asset_provenance_path_escape");
+    rmSync2(stale, { force: true });
+    rmSync2(`${stale}.meta.json`, { force: true });
+  }
+  for (const entry of item.manifest) {
+    const target = resolve6(stageRoot, entry.path);
+    if (!confined3(stageRoot, target))
+      throw new Error("asset_manifest_escape");
+    mkdirSync2(resolve6(target, ".."), { recursive: true, mode: 448 });
+    atomicWrite(target, fileBytesChecked(root, entry), 384);
+  }
+  return stageRoot;
+}
+function provenance(item, install, readback, refreshed) {
+  const rows = readback.rows;
+  const sourcePrefix = `assets/3d/ea-3d/${item.providerAssetId}/`;
+  return {
+    schemaVersion: PROVENANCE_SCHEMA,
+    provider: "ea-3d",
+    providerAssetId: item.providerAssetId,
+    adapterVersion: install.adapterVersion,
+    originSetDigest: install.originSetDigest,
+    aggregateSha256: item.sha256,
+    bytes: item.bytes,
+    deliveredFormat: item.deliveredFormat,
+    ...item.deliveredFormat === "pack" ? { primaryPack: item.primaryPack } : { primaryModel: item.primaryModel },
+    engine: { version: ENGINE_VERSION, commit: ENGINE_COMMIT },
+    refreshed,
+    files: item.manifest.map((entry) => ({
+      relativePath: entry.path,
+      role: entry.role,
+      sha256: entry.sha256,
+      bytes: entry.bytes,
+      engineRows: rows.filter((row) => row.source === `${sourcePrefix}${entry.path}`)
+    })),
+    catalog: { verify: readback.verify, list: readback.list, inspect: readback.inspect }
+  };
+}
+function commitItem(projectRoot, initialJournal, install, item, refresh, lockTimeoutMs, carrierPluginRoot) {
+  const destination = resolve6(projectRoot, "assets", "3d", "ea-3d", item.providerAssetId);
+  const assetRoot = resolve6(projectRoot, "assets", "3d", "ea-3d");
+  ensurePrivateDir(assetRoot);
+  if (!confined3(assetRoot, destination))
+    throw new Error("asset_destination_escape");
+  const releaseLock = acquireLock(projectRoot, item.providerAssetId, lockTimeoutMs);
+  let journal = initialJournal;
+  try {
+    const prior = priorProvenance(destination);
+    const priorDigest = typeof prior?.aggregateSha256 === "string" ? prior.aggregateSha256 : undefined;
+    if (priorDigest === item.sha256 && liveFilesMatch(destination, item)) {
+      const priorRows = Array.isArray(prior?.files) ? prior.files.flatMap((entry) => entry.engineRows ?? []) : [];
+      const baseReadback = item.deliveredFormat === "pack" ? packReadback(projectRoot, item, carrierPluginRoot) : engineReadback(projectRoot, `assets/3d/ea-3d/${item.providerAssetId}`, undefined, carrierPluginRoot);
+      const guids = priorRows.flatMap((row) => typeof row.guid === "string" ? [row.guid] : []);
+      const listed = Array.isArray(baseReadback.list) ? baseReadback.list : [];
+      if (guids.length === 0 || guids.some((guid) => !listed.some((entry) => entry.guid === guid)))
+        throw new Error("asset_reuse_readback_failed");
+      const readback = item.deliveredFormat === "pack" ? baseReadback : { ...baseReadback, inspect: guids.map((guid) => engineCommand(projectRoot, ["asset", "inspect", guid, "--json"], carrierPluginRoot).value) };
+      journal = updateJournal(projectRoot, journal, { state: "committed", previousDigest: priorDigest, newDigest: item.sha256 });
+      return { providerAssetId: item.providerAssetId, digest: item.sha256, bytes: item.bytes, reused: true, refreshed: false, sourcePath: relative4(projectRoot, destination), provenancePath: relative4(projectRoot, resolve6(destination, ".forgeax-asset.json")), engine: { version: ENGINE_VERSION, commit: ENGINE_COMMIT }, catalog: readback, rows: priorRows };
+    }
+    if (priorDigest && priorDigest !== item.sha256 && !refresh)
+      throw new Error("asset_changed");
+    const stage = stageItem(projectRoot, journal, item, destination, prior);
+    const backup = resolve6(forgeaxRoot(projectRoot), "asset3d-backups", journal.execution, item.providerAssetId);
+    ensurePrivateDir(resolve6(backup, ".."));
+    journal = updateJournal(projectRoot, journal, { state: "committing", destination, backupPath: existsSync4(destination) ? backup : undefined, previousDigest: priorDigest, newDigest: item.sha256 });
+    if (existsSync4(destination))
+      renameSync2(destination, backup);
+    renameSync2(stage, destination);
+    try {
+      const assetRelative = `assets/3d/ea-3d/${item.providerAssetId}`;
+      const readback = item.deliveredFormat === "pack" ? packReadback(projectRoot, item, carrierPluginRoot) : engineReadback(projectRoot, assetRelative, engineCommand(projectRoot, ["asset", "add", assetRelative, "--reimport-policy", "semantic-only", "--json"], carrierPluginRoot), carrierPluginRoot);
+      if (item.deliveredFormat === "pack" && !liveFilesMatch(destination, item))
+        throw new Error("engine_pack_source_changed");
+      atomicWrite(resolve6(destination, ".forgeax-asset.json"), `${JSON.stringify(provenance(item, install, readback, priorDigest !== undefined), null, 2)}
+`);
+      journal = updateJournal(projectRoot, journal, { state: "engine_verified" });
+      if (existsSync4(backup))
+        rmSync2(backup, { recursive: true, force: true });
+      journal = updateJournal(projectRoot, journal, { state: "committed" });
+      return { providerAssetId: item.providerAssetId, digest: item.sha256, bytes: item.bytes, reused: false, refreshed: priorDigest !== undefined, sourcePath: assetRelative, provenancePath: `${assetRelative}/.forgeax-asset.json`, engine: { version: ENGINE_VERSION, commit: ENGINE_COMMIT }, catalog: readback, rows: readback.rows };
+    } catch (error) {
+      rmSync2(destination, { recursive: true, force: true });
+      if (existsSync4(backup))
+        renameSync2(backup, destination);
+      updateJournal(projectRoot, journal, { state: "rolled_back", error: error instanceof Error ? error.message.slice(0, 256) : "engine failure" });
+      throw error;
+    }
+  } finally {
+    releaseLock();
+  }
+}
+function commitAsset3d(options) {
+  const projectRoot = realpathSync4(options.projectRoot);
+  const install = readInstall(projectRoot);
+  let journal = readJournal(projectRoot, options.execution);
+  if (journal.state !== "begun" && journal.state !== "provider_complete" && journal.state !== "validated") {
+    throw new Error(`asset3d_execution_state_invalid: ${journal.state}`);
+  }
+  if (journal.adapterVersion !== install.adapterVersion || journal.engineCommit !== ENGINE_COMMIT || journal.engineVersion !== ENGINE_VERSION) {
+    throw new Error("asset3d_execution_identity_mismatch");
+  }
+  let providerResult = options.providerResult;
+  if (providerResult === undefined) {
+    try {
+      providerResult = readFileSync6(providerResultPath(projectRoot, options.execution));
+    } catch {
+      throw new Error("asset3d_import_result_missing");
+    }
+  }
+  let result;
+  try {
+    result = parseProviderResult(providerResult, install.adapterVersion, install.originSetDigest);
+    if (result.total !== journal.requestedCount)
+      throw new Error("provider_result_invalid: requested count mismatch");
+    const orderedQueries = [...result.results].sort((left, right) => left.queryIndex - right.queryIndex).map((item) => item.query);
+    if (sha256(canonicalJson(orderedQueries)) !== journal.queryDigest) {
+      throw new Error("provider_result_invalid: query identity mismatch");
+    }
+    const successes = result.results.filter((item) => item.status === "ok");
+    validateQuarantine(journal, successes);
+    journal = updateJournal(projectRoot, journal, { state: "validated" });
+  } catch (error) {
+    rmSync2(journal.allowedQuarantineRoot, { recursive: true, force: true });
+    rmSync2(providerResultPath(projectRoot, options.execution), { force: true });
+    updateJournal(projectRoot, journal, {
+      state: "failed",
+      error: error instanceof Error ? error.message.slice(0, 256) : "provider validation failed"
+    });
+    throw error;
+  }
+  const terminal = [];
+  for (const item of result.results) {
+    if (item.status === "error") {
+      terminal.push(item);
+      continue;
+    }
+    try {
+      terminal.push({ status: "ok", ...commitItem(projectRoot, journal, install, item, options.refresh === true, options.lockTimeoutMs ?? 30000, options.carrierPluginRoot) });
+    } catch (error) {
+      terminal.push({ status: "error", providerAssetId: item.providerAssetId, code: error instanceof Error ? error.message.split(":", 1)[0] : "internal_error", retryable: false });
+    }
+  }
+  rmSync2(journal.allowedQuarantineRoot, { recursive: true, force: true });
+  rmSync2(providerResultPath(projectRoot, options.execution), { force: true });
+  const failed = terminal.filter((entry) => entry.status === "error").length;
+  updateJournal(projectRoot, journal, { state: failed === 0 ? "complete" : "failed" });
+  return {
+    schemaVersion: "forgeax.asset3d-commit-result/1.0.0",
+    execution: journal.execution,
+    succeeded: terminal.filter((entry) => entry.status === "ok").length,
+    failed,
+    results: terminal
+  };
+}
+function abortAsset3d(projectRootInput, execution) {
+  const projectRoot = realpathSync4(projectRootInput);
+  const journal = readJournal(projectRoot, execution);
+  if (journal.state === "committed" || journal.state === "complete" || journal.state === "engine_verified") {
+    throw new Error("asset3d_execution_already_committed");
+  }
+  rmSync2(journal.allowedQuarantineRoot, { recursive: true, force: true });
+  rmSync2(providerResultPath(projectRoot, execution), { force: true });
+  updateJournal(projectRoot, journal, { state: "aborted" });
+  return { execution, aborted: true };
+}
+function doctorAsset3d(projectRootInput, options = {}) {
+  const projectRoot = realpathSync4(projectRootInput);
+  const install = readInstall(projectRoot);
+  const release = resolveEngineRelease(projectRoot, options.carrierPluginRoot === undefined ? {} : { pluginRoot: options.carrierPluginRoot });
+  const recovered = [];
+  const root = resolve6(forgeaxRoot(projectRoot), "asset3d-transactions");
+  if (existsSync4(root))
+    for (const file of readdirSync2(root).filter((name) => name.endsWith(".json"))) {
+      try {
+        const path = resolve6(root, file);
+        const journal = JSON.parse(readFileSync6(path, "utf8"));
+        if (journal.schemaVersion !== TRANSACTION_SCHEMA || journal.state !== "committing" || !journal.destination)
+          continue;
+        const assetsRoot = resolve6(projectRoot, "assets", "3d", "ea-3d");
+        const backupsRoot = resolve6(forgeaxRoot(projectRoot), "asset3d-backups");
+        if (!confined3(assetsRoot, journal.destination) || journal.backupPath && !confined3(backupsRoot, journal.backupPath))
+          continue;
+        rmSync2(journal.destination, { recursive: true, force: true });
+        if (journal.backupPath && existsSync4(journal.backupPath))
+          renameSync2(journal.backupPath, journal.destination);
+        updateJournal(projectRoot, journal, { state: "rolled_back", error: "stale_committing_recovered" });
+        recovered.push(journal.execution);
+      } catch {}
+    }
+  return { installed: true, recovered, engine: { version: release.version, commit: release.commit }, adapter: { version: install.adapterVersion, transport: "http" }, access: "not_checked" };
+}
+
+// extensions/asset3d/src/library.ts
+var MAX_FILE = 128 * 1024 * 1024;
+var MAX_TOTAL = 256 * 1024 * 1024;
+function unpackAsset(bytes, format) {
+  const seen = new Set;
+  let total = 0;
+  const check = (path2, size) => {
+    safeRelativePath(path2);
+    if (/[\x00-\x1f:]/.test(path2) || path2.split("/").some((p) => /[. ]$/.test(p) || /^(con|prn|aux|nul|com[1-9]|lpt[1-9])(\.|$)/i.test(p))) {
+      throw new Error("asset3d_archive_path_invalid");
+    }
+    const key = path2.normalize("NFC").toLowerCase();
+    if (seen.has(key) || seen.size >= 1024 || size < 1 || size > MAX_FILE || (total += size) > MAX_TOTAL) {
+      throw new Error("asset3d_archive_limits");
+    }
+    seen.add(key);
+  };
+  if (format === "zip") {
+    let files;
+    try {
+      files = unzipSync(bytes, { filter(entry) {
+        if (entry.name.endsWith("/")) {
+          safeRelativePath(entry.name.slice(0, -1));
+          return false;
+        }
+        check(entry.name, entry.originalSize);
+        return true;
+      } });
+    } catch {
+      throw new Error("asset3d_archive_rejected");
+    }
+    for (const path2 of Object.keys(files)) {
+      let parent = path2;
+      while (parent.includes("/")) {
+        parent = parent.slice(0, parent.lastIndexOf("/"));
+        if (seen.has(parent.normalize("NFC").toLowerCase()))
+          throw new Error("asset3d_archive_path_conflict");
+      }
+      if (!files[path2].length || files[path2].length > MAX_FILE)
+        throw new Error("asset3d_archive_limits");
+    }
+    return files;
+  }
+  if (!["glb", "pack.ts", "pack.json"].includes(format))
+    throw new Error("asset3d_format_unsupported");
+  const path = "asset." + format;
+  check(path, bytes.length);
+  return { [path]: bytes };
+}
+function manifestFor(files, prefix) {
+  const paths = Object.keys(files).sort((a, b) => Buffer.from(a).compare(Buffer.from(b)));
+  const packs = paths.filter((p) => /\.pack\.(ts|json)$/i.test(p));
+  const models = paths.filter((p) => /\.glb$/i.test(p));
+  const primary = packs[0] ?? models.find((p) => /(^|\/)SM_/i.test(p)) ?? models[0];
+  if (!primary)
+    throw new Error("asset3d_supported_source_missing");
+  for (const path of models) {
+    const bytes = Buffer.from(files[path]);
+    if (bytes.length < 12 || bytes.toString("ascii", 0, 4) !== "glTF" || bytes.readUInt32LE(4) !== 2 || bytes.readUInt32LE(8) !== bytes.length) {
+      throw new Error("asset3d_glb_invalid");
+    }
+  }
+  const manifest = paths.map((path) => ({
+    path: prefix + "/" + path,
+    role: packs.includes(path) ? path === primary ? "primary-pack" : "auxiliary-pack" : models.includes(path) ? path === primary ? "primary-model" : "auxiliary-model" : /\.(png|jpg|jpeg|webp|ktx2)$/i.test(path) ? "texture" : "metadata",
+    bytes: files[path].length,
+    sha256: sha256(files[path])
+  }));
+  return {
+    manifest,
+    primary: prefix + "/" + primary,
+    deliveredFormat: packs.length ? "pack" : "glb",
+    bytes: manifest.reduce((n, e) => n + e.bytes, 0),
+    sha256: sha256(manifest.map((e) => `${e.path}\x00${e.bytes}\x00${e.sha256}
+`).join(""))
+  };
+}
+async function download(config, candidate) {
+  if (!config.downloadOrigins.includes(downloadOrigin(candidate.downloadUrl))) {
+    throw new Error("asset3d_download_origin_rejected: enable again to refresh allowed origins");
+  }
+  let response;
+  try {
+    response = await fetch(candidate.downloadUrl, { redirect: "error", signal: AbortSignal.timeout(120000) });
+  } catch {
+    throw new Error("asset3d_download_unreachable");
+  }
+  if (!response.ok)
+    throw new Error(`asset3d_download_http_${response.status}`);
+  const bytes = await boundedResponse(response, MAX_TOTAL);
+  const path = new URL(candidate.downloadUrl).pathname;
+  const format = /\.pack\.(ts|json)$/i.exec(path)?.[0].slice(1) ?? candidate.format.replace(/^\./, "");
+  return unpackAsset(bytes, format);
+}
+async function candidatesAsset3d(root, query) {
+  const candidates = await searchLibrary(readAsset3dConfig(root), query);
+  return { candidates: candidates.map(({ assetId, name, format }) => ({ assetId, name, format })) };
+}
+async function importAsset3d(root, query, assetId) {
+  const config = readAsset3dConfig(root);
+  const candidate = (await searchLibrary(config, query)).find((c) => c.assetId === assetId);
+  if (!candidate)
+    throw new Error("asset3d_candidate_not_found: select an ID returned for this query");
+  const files = await download(config, candidate);
+  const built = manifestFor(files, candidate.assetId);
+  const started = beginAsset3d(root, [query]);
+  try {
+    const output = asset3dSearchOutputDir(root, started.execution, [query]);
+    for (const [path, bytes] of Object.entries(files)) {
+      const target = resolve7(root, ".forgeax/extensions/asset3d/data/asset3d-quarantine", output, candidate.assetId, path);
+      mkdirSync3(dirname4(target), { recursive: true, mode: 448 });
+      writeFileSync4(target, bytes, { flag: "wx", mode: 384 });
+    }
+    const result = {
+      schemaVersion: PROVIDER_RESULT_SCHEMA,
+      total: 1,
+      succeeded: 1,
+      failed: 0,
+      receipt: {
+        schemaVersion: PROVIDER_RECEIPT_SCHEMA,
+        provider: "ea-3d",
+        adapterVersion: config.adapterVersion,
+        originSetDigest: config.originSetDigest
+      },
+      results: [{
+        status: "ok",
+        queryIndex: 0,
+        query,
+        provider: "ea-3d",
+        providerAssetId: assetId,
+        assetName: candidate.name,
+        sha256: built.sha256,
+        bytes: built.bytes,
+        manifest: built.manifest,
+        originSetDigest: config.originSetDigest,
+        ...built.deliveredFormat === "pack" ? { deliveredFormat: "pack", primaryPack: built.primary } : { deliveredFormat: "glb", primaryModel: built.primary }
+      }]
+    };
+    recordAsset3dProviderResult(root, started.execution, JSON.stringify(result));
+    const committed = commitAsset3d({ projectRoot: root, execution: started.execution });
+    return { ...committed, deliveredFormat: built.deliveredFormat };
+  } catch (error) {
+    try {
+      abortAsset3d(root, started.execution);
+    } catch {}
+    throw error;
+  }
+}
+function parseAsset3dArgs(args, importing) {
+  const allowed = importing ? ["--query", "--asset-id"] : ["--query"];
+  const values = {};
+  for (let i2 = 0;i2 < args.length; i2++) {
+    if (args[i2] === "--json")
+      continue;
+    const name = args[i2], value = args[++i2];
+    if (!allowed.includes(name) || values[name] || !value || value.startsWith("--"))
+      throw new Error("asset3d_arguments_invalid");
+    values[name] = value;
+  }
+  if (allowed.some((name) => !values[name]))
+    throw new Error("asset3d_arguments_invalid");
+  return { query: values["--query"], assetId: values["--asset-id"] };
+}
+
+// extensions/asset3d/cli.ts
+async function check(context, args) {
+  let library;
+  let baseUrl;
+  for (let i2 = 0;i2 < args.length; i2++) {
+    const option = args[i2];
+    if (option === "--json")
+      continue;
+    if (option === "--library" && ["aw", "ea"].includes(args[i2 + 1]))
+      library = args[++i2];
+    else if (option === "--base-url" && args[i2 + 1])
+      baseUrl = args[++i2];
+    else
+      throw new Error("asset3d_arguments_invalid: enable [--library aw|ea] [--base-url URL]");
+  }
+  const selected = resolveAssetLibrarySelection({ library, baseUrl });
+  const credentialFile = defaultAwCredentialFile();
+  const credential = await acquireAwKey(credentialFile, !args.includes("--json"));
+  const pending = writeAwCredential(credentialFile, credential.key);
+  try {
+    const access = await checkAssetLibraryAccess({ ...selected, credentialFile });
+    pending.commit();
+    return {
+      schemaVersion: INSTALL_SCHEMA,
+      adapterVersion: context.packageVersion,
+      ...selected,
+      credentialFile,
+      downloadOrigins: access.downloadOrigins,
+      originSetDigest: canonicalizeOrigins(access.downloadOrigins).digest
+    };
+  } catch (error) {
+    pending.rollback();
+    throw error;
+  }
+}
+async function run(context, args) {
+  const [operation, ...rest] = args;
+  if (operation === "doctor") {
+    if (rest.some((arg) => arg !== "--json"))
+      throw new Error("asset3d_arguments_invalid");
+    return doctorAsset3d(context.projectRoot);
+  }
+  if (operation === "candidates" || operation === "import") {
+    const parsed = parseAsset3dArgs(rest, operation === "import");
+    return operation === "candidates" ? candidatesAsset3d(context.projectRoot, parsed.query) : importAsset3d(context.projectRoot, parsed.query, parsed.assetId);
+  }
+  throw new Error("asset3d_arguments_invalid: expected candidates, import, or doctor");
+}
+export {
+  check,
+  run
+};