@econ-v1/app-sdk 7.4.0 → 7.4.2

package/dist/burger-build/aliases.d.ts

@@ -14,8 +14,26 @@ export declare const ALIASES: ReadonlyMap<string, BurgerModule>;
  * (`ws`, `undici`) that apps legitimately depend on.
  */
 export declare const NODE_BUILTINS: ReadonlySet<string>;
-/** Named exports of each `burger:*` module (C4, C6). Used to bridge CommonJS `require()`. */
+/**
+ * Named exports of each `burger:*` module (C4, C6). Used to bridge CommonJS
+ * `require()`.
+ *
+ * DATA-APP PACK: `realpathSync`, `copyFileSync`, `symlinkSync`, `openSync`,
+ * `writeSync`, `fsyncSync`, `fdatasyncSync`, `closeSync`, `Dirent` and
+ * `constants` on `burger:fs` ship with the data-app pack
+ * (econ-v1/node-app-burger#12), not Phase 1. They are listed here so the
+ * build-time gate accepts them ahead of a runtime that provides them; an app
+ * using them must depend on that node-app-burger release. `readSync`,
+ * `fstatSync` and `utimesSync` arrive with the second data-app pack (asked
+ * for by the node-app-memory flip, econ-v1/node-app-memory#40).
+ */
 export declare const BURGER_EXPORTS: Readonly<Record<BurgerModule, readonly string[]>>;
+/**
+ * `burger:*` modules with a `default` export (C6): every module except
+ * `burger:host` and `burger:test` (verified against the runtime JS in
+ * node-app-burger). `import x from "burger:host"` fails to link.
+ */
+export declare const BURGER_DEFAULT_EXPORT: Readonly<Partial<Record<BurgerModule, true>>>;
 export type SpecifierClass = {
     kind: "burger";
     target: BurgerModule;

package/dist/burger-build/cli.js

@@ -20,134 +20,6 @@ function assertSupportedBun(version = Bun.version) {
 // ../burger-build/src/gate.ts
 import { readFileSync } from "fs";
 import { extname, isAbsolute, relative, resolve } from "path";
-var FS_SPECIFIERS = new Set([
-  "fs",
-  "node:fs",
-  "fs/promises",
-  "node:fs/promises",
-  "burger:fs",
-  "burger:fs/promises"
-]);
-var BUN_GLOBAL = /(?<![\w$.'"`])Bun\s*\.\s*[A-Za-z_$]|\bglobalThis\s*\.\s*Bun\b/;
-var IMPORT_META_PATH = /\bimport\.meta\.(?:url|dir|dirname|filename|path)\b/;
-var NATIVE_LOADER_PACKAGE = /[\\/]node_modules[\\/](?:bindings|node-gyp-build)[\\/]/;
-function metafileKeyToPath(key, cwd) {
-  if (isAbsolute(key))
-    return key;
-  const colon = key.indexOf(":");
-  const slash = key.indexOf("/");
-  if (colon > 0 && (slash === -1 || colon < slash))
-    return key;
-  return resolve(cwd, key);
-}
-function importerGraph(metafile, cwd) {
-  const parents = new Map;
-  for (const [key, input] of Object.entries(metafile.inputs)) {
-    const importer = metafileKeyToPath(key, cwd);
-    for (const record of input.imports) {
-      if (record.external)
-        continue;
-      const child = metafileKeyToPath(record.path, cwd);
-      if (child !== importer && !parents.has(child)) {
-        parents.set(child, importer);
-      }
-    }
-  }
-  return parents;
-}
-function importerChain(file, parents) {
-  const chain = [file];
-  const seen = new Set(chain);
-  let current = parents.get(file);
-  while (current !== undefined && !seen.has(current)) {
-    chain.unshift(current);
-    seen.add(current);
-    current = parents.get(current);
-  }
-  return chain;
-}
-function loaderFor(file) {
-  switch (extname(file)) {
-    case ".ts":
-    case ".mts":
-    case ".cts":
-      return "ts";
-    case ".tsx":
-      return "tsx";
-    case ".jsx":
-      return "jsx";
-    case ".js":
-    case ".mjs":
-    case ".cjs":
-      return "js";
-    default:
-      return;
-  }
-}
-function codeOf(file, source) {
-  const loader = loaderFor(file);
-  if (!loader)
-    return;
-  try {
-    return new Bun.Transpiler({ loader }).transformSync(source);
-  } catch {
-    return source;
-  }
-}
-function scanModule(file, code, importedSpecifiers) {
-  const messages = [];
-  if (BUN_GLOBAL.test(code)) {
-    messages.push("uses the Bun global (Bun.*), which does not exist in Burger");
-  }
-  if (IMPORT_META_PATH.test(code) && importedSpecifiers.some((specifier) => FS_SPECIFIERS.has(specifier))) {
-    messages.push("reads files relative to import.meta; bundling moves this module, so the files are not found at runtime \u2014 import the data statically instead");
-  }
-  if (NATIVE_LOADER_PACKAGE.test(file)) {
-    messages.push("loads a native addon (bindings/node-gyp-build), which Burger cannot run");
-  }
-  return messages;
-}
-function collectProblems(metafile, violations, cwd) {
-  const parents = importerGraph(metafile, cwd);
-  const problems = [];
-  for (const violation of violations) {
-    problems.push({
-      message: `import "${violation.specifier}": ${violation.reason}`,
-      chain: importerChain(violation.importer, parents)
-    });
-  }
-  for (const [key, input] of Object.entries(metafile.inputs)) {
-    const file = metafileKeyToPath(key, cwd);
-    if (!isAbsolute(file))
-      continue;
-    let source;
-    try {
-      source = readFileSync(file, "utf8");
-    } catch {
-      continue;
-    }
-    const code = codeOf(file, source);
-    if (code === undefined)
-      continue;
-    const specifiers = input.imports.flatMap((record) => record.original === undefined ? [record.path] : [record.path, record.original]);
-    for (const message of scanModule(file, code, specifiers)) {
-      problems.push({ message, chain: importerChain(file, parents) });
-    }
-  }
-  return problems;
-}
-function formatProblems(problems, cwd) {
-  const lines = [`burger-build: ${problems.length} problem(s) \u2014 this code cannot run on Burger:`];
-  for (const problem of problems) {
-    lines.push(`  \u2717 ${problem.message}`);
-    problem.chain.forEach((file, index) => {
-      const shown = isAbsolute(file) ? relative(cwd, file) : file;
-      lines.push(index === 0 ? `      ${shown}` : `      \u2192 ${shown}`);
-    });
-  }
-  return lines.join(`
-`);
-}
 
 // ../burger-build/src/aliases.ts
 var BURGER_MODULES = [
@@ -265,7 +137,20 @@ var BURGER_EXPORTS = {
     "chmodSync",
     "unlinkSync",
     "mkdtempSync",
-    "promises"
+    "promises",
+    "realpathSync",
+    "copyFileSync",
+    "symlinkSync",
+    "openSync",
+    "writeSync",
+    "fsyncSync",
+    "fdatasyncSync",
+    "closeSync",
+    "Dirent",
+    "constants",
+    "readSync",
+    "fstatSync",
+    "utimesSync"
   ],
   "burger:fs/promises": [
     "exists",
@@ -313,6 +198,16 @@ var BURGER_EXPORTS = {
     "setDefaultTimeout"
   ]
 };
+var BURGER_DEFAULT_EXPORT = {
+  "burger:fs": true,
+  "burger:fs/promises": true,
+  "burger:path": true,
+  "burger:os": true,
+  "burger:worker_threads": true,
+  "burger:crypto": true,
+  "burger:buffer": true,
+  "burger:sqlite": true
+};
 var BURGER_MODULE_SET = new Set(BURGER_MODULES);
 function classifySpecifier(specifier) {
   if (BURGER_MODULE_SET.has(specifier)) {
@@ -340,6 +235,191 @@ function classifySpecifier(specifier) {
   return { kind: "other" };
 }
 
+// ../burger-build/src/gate.ts
+var FS_SPECIFIERS = new Set([
+  "fs",
+  "node:fs",
+  "fs/promises",
+  "node:fs/promises",
+  "burger:fs",
+  "burger:fs/promises"
+]);
+var BUN_GLOBAL = /(?<![\w$.'"`])Bun\s*\.\s*[A-Za-z_$]|\bglobalThis\s*\.\s*Bun\b/;
+var IMPORT_META_PATH = /\bimport\.meta\.(?:url|dir|dirname|filename|path)\b/;
+var IMPORT_OR_REEXPORT = /\b(?:import|export)\s+([^;]+?)\s+from\s*["']([^"']+)["']/g;
+function parseNamedList(braced, into) {
+  for (const rawItem of braced.replace(/^\{|\}$/g, "").split(",")) {
+    const item = rawItem.trim();
+    if (item === "" || item.startsWith("type "))
+      continue;
+    const asMatch = /^([\w$]+|default)\s+as\s+[\w$]+$/.exec(item);
+    if (asMatch)
+      into.push(asMatch[1]);
+    else if (/^[\w$]+$/.test(item) || item === "default")
+      into.push(item);
+  }
+}
+function parseClause(raw) {
+  const clause = raw.trim();
+  const result = { named: [] };
+  if (clause.startsWith("type ") || clause.startsWith("*"))
+    return result;
+  if (clause.startsWith("{")) {
+    parseNamedList(clause, result.named);
+    return result;
+  }
+  const match = /^([\w$]+)\s*(?:,\s*([\s\S]+))?$/.exec(clause);
+  if (!match)
+    return result;
+  result.named.push("default");
+  const trailing = match[2]?.trim();
+  if (trailing?.startsWith("{"))
+    parseNamedList(trailing, result.named);
+  return result;
+}
+function missingExportMessage(target, name, specifier) {
+  return `"${target}" has no export "${name}" (imported as "${specifier}"); Burger provides: ${BURGER_EXPORTS[target].join(", ")}`;
+}
+function scanBurgerImports(code) {
+  const messages = [];
+  const reported = new Set;
+  for (const match of code.matchAll(IMPORT_OR_REEXPORT)) {
+    const specifier = match[2];
+    const specifierClass = classifySpecifier(specifier);
+    if (specifierClass.kind !== "burger")
+      continue;
+    const target = specifierClass.target;
+    for (const name of parseClause(match[1]).named) {
+      const provided = name === "default" ? target in BURGER_DEFAULT_EXPORT : BURGER_EXPORTS[target].includes(name);
+      const key = `${target}\x00${name}\x00${specifier}`;
+      if (provided || reported.has(key))
+        continue;
+      reported.add(key);
+      messages.push(missingExportMessage(target, name, specifier));
+    }
+  }
+  return messages;
+}
+var NATIVE_LOADER_PACKAGE = /[\\/]node_modules[\\/](?:bindings|node-gyp-build)[\\/]/;
+function metafileKeyToPath(key, cwd) {
+  if (isAbsolute(key))
+    return key;
+  const colon = key.indexOf(":");
+  const slash = key.indexOf("/");
+  if (colon > 0 && (slash === -1 || colon < slash))
+    return key;
+  return resolve(cwd, key);
+}
+function importerGraph(metafile, cwd) {
+  const parents = new Map;
+  for (const [key, input] of Object.entries(metafile.inputs)) {
+    const importer = metafileKeyToPath(key, cwd);
+    for (const record of input.imports) {
+      if (record.external)
+        continue;
+      const child = metafileKeyToPath(record.path, cwd);
+      if (child !== importer && !parents.has(child)) {
+        parents.set(child, importer);
+      }
+    }
+  }
+  return parents;
+}
+function importerChain(file, parents) {
+  const chain = [file];
+  const seen = new Set(chain);
+  let current = parents.get(file);
+  while (current !== undefined && !seen.has(current)) {
+    chain.unshift(current);
+    seen.add(current);
+    current = parents.get(current);
+  }
+  return chain;
+}
+function loaderFor(file) {
+  switch (extname(file)) {
+    case ".ts":
+    case ".mts":
+    case ".cts":
+      return "ts";
+    case ".tsx":
+      return "tsx";
+    case ".jsx":
+      return "jsx";
+    case ".js":
+    case ".mjs":
+    case ".cjs":
+      return "js";
+    default:
+      return;
+  }
+}
+function codeOf(file, source) {
+  const loader = loaderFor(file);
+  if (!loader)
+    return;
+  try {
+    return new Bun.Transpiler({ loader }).transformSync(source);
+  } catch {
+    return source;
+  }
+}
+function scanModule(file, code, importedSpecifiers) {
+  const messages = [];
+  if (BUN_GLOBAL.test(code)) {
+    messages.push("uses the Bun global (Bun.*), which does not exist in Burger");
+  }
+  if (IMPORT_META_PATH.test(code) && importedSpecifiers.some((specifier) => FS_SPECIFIERS.has(specifier))) {
+    messages.push("reads files relative to import.meta; bundling moves this module, so the files are not found at runtime \u2014 import the data statically instead");
+  }
+  if (NATIVE_LOADER_PACKAGE.test(file)) {
+    messages.push("loads a native addon (bindings/node-gyp-build), which Burger cannot run");
+  }
+  messages.push(...scanBurgerImports(code));
+  return messages;
+}
+function collectProblems(metafile, violations, cwd) {
+  const parents = importerGraph(metafile, cwd);
+  const problems = [];
+  for (const violation of violations) {
+    problems.push({
+      message: `import "${violation.specifier}": ${violation.reason}`,
+      chain: importerChain(violation.importer, parents)
+    });
+  }
+  for (const [key, input] of Object.entries(metafile.inputs)) {
+    const file = metafileKeyToPath(key, cwd);
+    if (!isAbsolute(file))
+      continue;
+    let source;
+    try {
+      source = readFileSync(file, "utf8");
+    } catch {
+      continue;
+    }
+    const code = codeOf(file, source);
+    if (code === undefined)
+      continue;
+    const specifiers = input.imports.flatMap((record) => record.original === undefined ? [record.path] : [record.path, record.original]);
+    for (const message of scanModule(file, code, specifiers)) {
+      problems.push({ message, chain: importerChain(file, parents) });
+    }
+  }
+  return problems;
+}
+function formatProblems(problems, cwd) {
+  const lines = [`burger-build: ${problems.length} problem(s) \u2014 this code cannot run on Burger:`];
+  for (const problem of problems) {
+    lines.push(`  \u2717 ${problem.message}`);
+    problem.chain.forEach((file, index) => {
+      const shown = isAbsolute(file) ? relative(cwd, file) : file;
+      lines.push(index === 0 ? `      ${shown}` : `      \u2192 ${shown}`);
+    });
+  }
+  return lines.join(`
+`);
+}
+
 // ../burger-build/src/plugin.ts
 var BRIDGE_NAMESPACE = "burger-require";
 var BRIDGE_PREFIX = "cjs-bridge/";
@@ -515,22 +595,36 @@ function relativeSpecifier(fromDir, to) {
   const rel = relative2(fromDir, to).split(sep).join("/");
   return rel.startsWith(".") ? rel : `./${rel}`;
 }
+var JS_TO_TS_SUFFIXES = {
+  ".js": [".ts", ".tsx"],
+  ".jsx": [".tsx"],
+  ".mjs": [".mts"],
+  ".cjs": []
+};
 function resolveRelativeFile(importerDir, specifier) {
   const base = resolve2(importerDir, specifier);
+  const isFile = (candidate) => existsSync(candidate) && statSync(candidate).isFile();
+  if (isFile(base))
+    return base;
+  const mapped = JS_TO_TS_SUFFIXES[extname2(specifier)];
+  if (mapped !== undefined) {
+    const stem = base.slice(0, base.length - extname2(specifier).length);
+    return mapped.map((suffix) => stem + suffix).find(isFile);
+  }
   const candidates = [
-    base,
     ...RESOLVE_SUFFIXES.map((suffix) => base + suffix),
     ...RESOLVE_SUFFIXES.map((suffix) => join2(base, `index${suffix}`))
   ];
-  return candidates.find((candidate) => existsSync(candidate) && statSync(candidate).isFile());
+  return candidates.find(isFile);
 }
 function dependencyFileName(specifier) {
   return specifier.replace(/^@/, "").replace(/[\\/]/g, "__") + ".js";
 }
+var TEXT_NAMESPACE = "burger-text";
 function rewriteSpecifier(ws, importer, specifier) {
   const specifierClass = classifySpecifier(specifier);
   if (specifierClass.kind === "burger")
-    return specifierClass.target;
+    return { external: specifierClass.target };
   if (specifierClass.kind === "forbidden") {
     ws.problems.push({ message: `import "${specifier}": ${specifierClass.reason}`, chain: [importer] });
     return;
@@ -547,7 +641,14 @@ function rewriteSpecifier(ws, importer, specifier) {
         return;
       }
       ws.jsonFiles.add(target);
-      return `${relativeSpecifier(dirname(importer), target)}.js`;
+      return { external: `${relativeSpecifier(dirname(importer), target)}.js` };
+    }
+    if (!isCodeFile(target)) {
+      if (!isInside(target, ws.root)) {
+        ws.problems.push({ message: `"${specifier}" is outside ${ws.root}`, chain: [importer] });
+        return;
+      }
+      return { inline: target };
     }
     if (!ws.sources.has(target)) {
       ws.problems.push({
@@ -556,7 +657,7 @@ function rewriteSpecifier(ws, importer, specifier) {
       });
       return;
     }
-    return preparedPath(relativeSpecifier(dirname(importer), target));
+    return { external: preparedPath(relativeSpecifier(dirname(importer), target)) };
   }
   if (specifier.startsWith("#")) {
     ws.problems.push({
@@ -566,7 +667,7 @@ function rewriteSpecifier(ws, importer, specifier) {
     return;
   }
   ws.dependencies.add(specifier);
-  return specifier;
+  return { external: specifier };
 }
 function moduleIdentity(importer, specifier) {
   const specifierClass = classifySpecifier(specifier);
@@ -610,8 +711,17 @@ function sourcesPlugin(ws) {
           });
           return { path: args.path, external: true };
         }
-        return { path: rewriteSpecifier(ws, args.importer, args.path) ?? args.path, external: true };
+        const resolved = rewriteSpecifier(ws, args.importer, args.path);
+        if (resolved === undefined)
+          return { path: args.path, external: true };
+        if ("inline" in resolved)
+          return { path: resolved.inline, namespace: TEXT_NAMESPACE, external: false };
+        return { path: resolved.external, external: true };
       });
+      build.onLoad({ filter: /.*/, namespace: TEXT_NAMESPACE }, (args) => ({
+        contents: readFileSync2(args.path, "utf8"),
+        loader: "text"
+      }));
     }
   };
 }
@@ -736,7 +846,8 @@ async function prepareTests(options) {
     const output = join2(out, preparedPath(relative2(root, file)));
     const prepared = readFileSync2(output, "utf8").replace(MOCK_MODULE_CALL, (call, quote, specifier) => {
       const rewritten = rewriteSpecifier(ws, file, specifier);
-      return rewritten === undefined ? call : call.replace(`${quote}${specifier}${quote}`, JSON.stringify(rewritten));
+      const replacement = rewritten === undefined ? undefined : ("external" in rewritten) ? rewritten.external : undefined;
+      return replacement === undefined ? call : call.replace(`${quote}${specifier}${quote}`, JSON.stringify(replacement));
     });
     writeFileSync2(output, prepared);
     const source = readFileSync2(file, "utf8");

package/dist/burger-build/gate.d.ts

@@ -15,6 +15,8 @@ export interface Problem {
     /** Entry point first, offending module last; absolute paths. */
     chain: string[];
 }
+/** Problems from importing a name a `burger:*` module does not export. */
+export declare function scanBurgerImports(code: string): string[];
 /** Metafile keys are relative to the process cwd; namespaced keys (`ns:path`) are left as-is. */
 export declare function metafileKeyToPath(key: string, cwd: string): string;
 /** child → first importer, over resolved (non-external) imports. */

package/dist/burger-build/index.js

@@ -15,134 +15,6 @@ function assertSupportedBun(version = Bun.version) {
 // ../burger-build/src/gate.ts
 import { readFileSync } from "fs";
 import { extname, isAbsolute, relative, resolve } from "path";
-var FS_SPECIFIERS = new Set([
-  "fs",
-  "node:fs",
-  "fs/promises",
-  "node:fs/promises",
-  "burger:fs",
-  "burger:fs/promises"
-]);
-var BUN_GLOBAL = /(?<![\w$.'"`])Bun\s*\.\s*[A-Za-z_$]|\bglobalThis\s*\.\s*Bun\b/;
-var IMPORT_META_PATH = /\bimport\.meta\.(?:url|dir|dirname|filename|path)\b/;
-var NATIVE_LOADER_PACKAGE = /[\\/]node_modules[\\/](?:bindings|node-gyp-build)[\\/]/;
-function metafileKeyToPath(key, cwd) {
-  if (isAbsolute(key))
-    return key;
-  const colon = key.indexOf(":");
-  const slash = key.indexOf("/");
-  if (colon > 0 && (slash === -1 || colon < slash))
-    return key;
-  return resolve(cwd, key);
-}
-function importerGraph(metafile, cwd) {
-  const parents = new Map;
-  for (const [key, input] of Object.entries(metafile.inputs)) {
-    const importer = metafileKeyToPath(key, cwd);
-    for (const record of input.imports) {
-      if (record.external)
-        continue;
-      const child = metafileKeyToPath(record.path, cwd);
-      if (child !== importer && !parents.has(child)) {
-        parents.set(child, importer);
-      }
-    }
-  }
-  return parents;
-}
-function importerChain(file, parents) {
-  const chain = [file];
-  const seen = new Set(chain);
-  let current = parents.get(file);
-  while (current !== undefined && !seen.has(current)) {
-    chain.unshift(current);
-    seen.add(current);
-    current = parents.get(current);
-  }
-  return chain;
-}
-function loaderFor(file) {
-  switch (extname(file)) {
-    case ".ts":
-    case ".mts":
-    case ".cts":
-      return "ts";
-    case ".tsx":
-      return "tsx";
-    case ".jsx":
-      return "jsx";
-    case ".js":
-    case ".mjs":
-    case ".cjs":
-      return "js";
-    default:
-      return;
-  }
-}
-function codeOf(file, source) {
-  const loader = loaderFor(file);
-  if (!loader)
-    return;
-  try {
-    return new Bun.Transpiler({ loader }).transformSync(source);
-  } catch {
-    return source;
-  }
-}
-function scanModule(file, code, importedSpecifiers) {
-  const messages = [];
-  if (BUN_GLOBAL.test(code)) {
-    messages.push("uses the Bun global (Bun.*), which does not exist in Burger");
-  }
-  if (IMPORT_META_PATH.test(code) && importedSpecifiers.some((specifier) => FS_SPECIFIERS.has(specifier))) {
-    messages.push("reads files relative to import.meta; bundling moves this module, so the files are not found at runtime \u2014 import the data statically instead");
-  }
-  if (NATIVE_LOADER_PACKAGE.test(file)) {
-    messages.push("loads a native addon (bindings/node-gyp-build), which Burger cannot run");
-  }
-  return messages;
-}
-function collectProblems(metafile, violations, cwd) {
-  const parents = importerGraph(metafile, cwd);
-  const problems = [];
-  for (const violation of violations) {
-    problems.push({
-      message: `import "${violation.specifier}": ${violation.reason}`,
-      chain: importerChain(violation.importer, parents)
-    });
-  }
-  for (const [key, input] of Object.entries(metafile.inputs)) {
-    const file = metafileKeyToPath(key, cwd);
-    if (!isAbsolute(file))
-      continue;
-    let source;
-    try {
-      source = readFileSync(file, "utf8");
-    } catch {
-      continue;
-    }
-    const code = codeOf(file, source);
-    if (code === undefined)
-      continue;
-    const specifiers = input.imports.flatMap((record) => record.original === undefined ? [record.path] : [record.path, record.original]);
-    for (const message of scanModule(file, code, specifiers)) {
-      problems.push({ message, chain: importerChain(file, parents) });
-    }
-  }
-  return problems;
-}
-function formatProblems(problems, cwd) {
-  const lines = [`burger-build: ${problems.length} problem(s) \u2014 this code cannot run on Burger:`];
-  for (const problem of problems) {
-    lines.push(`  \u2717 ${problem.message}`);
-    problem.chain.forEach((file, index) => {
-      const shown = isAbsolute(file) ? relative(cwd, file) : file;
-      lines.push(index === 0 ? `      ${shown}` : `      \u2192 ${shown}`);
-    });
-  }
-  return lines.join(`
-`);
-}
 
 // ../burger-build/src/aliases.ts
 var BURGER_MODULES = [
@@ -260,7 +132,20 @@ var BURGER_EXPORTS = {
     "chmodSync",
     "unlinkSync",
     "mkdtempSync",
-    "promises"
+    "promises",
+    "realpathSync",
+    "copyFileSync",
+    "symlinkSync",
+    "openSync",
+    "writeSync",
+    "fsyncSync",
+    "fdatasyncSync",
+    "closeSync",
+    "Dirent",
+    "constants",
+    "readSync",
+    "fstatSync",
+    "utimesSync"
   ],
   "burger:fs/promises": [
     "exists",
@@ -308,6 +193,16 @@ var BURGER_EXPORTS = {
     "setDefaultTimeout"
   ]
 };
+var BURGER_DEFAULT_EXPORT = {
+  "burger:fs": true,
+  "burger:fs/promises": true,
+  "burger:path": true,
+  "burger:os": true,
+  "burger:worker_threads": true,
+  "burger:crypto": true,
+  "burger:buffer": true,
+  "burger:sqlite": true
+};
 var BURGER_MODULE_SET = new Set(BURGER_MODULES);
 function classifySpecifier(specifier) {
   if (BURGER_MODULE_SET.has(specifier)) {
@@ -335,6 +230,191 @@ function classifySpecifier(specifier) {
   return { kind: "other" };
 }
 
+// ../burger-build/src/gate.ts
+var FS_SPECIFIERS = new Set([
+  "fs",
+  "node:fs",
+  "fs/promises",
+  "node:fs/promises",
+  "burger:fs",
+  "burger:fs/promises"
+]);
+var BUN_GLOBAL = /(?<![\w$.'"`])Bun\s*\.\s*[A-Za-z_$]|\bglobalThis\s*\.\s*Bun\b/;
+var IMPORT_META_PATH = /\bimport\.meta\.(?:url|dir|dirname|filename|path)\b/;
+var IMPORT_OR_REEXPORT = /\b(?:import|export)\s+([^;]+?)\s+from\s*["']([^"']+)["']/g;
+function parseNamedList(braced, into) {
+  for (const rawItem of braced.replace(/^\{|\}$/g, "").split(",")) {
+    const item = rawItem.trim();
+    if (item === "" || item.startsWith("type "))
+      continue;
+    const asMatch = /^([\w$]+|default)\s+as\s+[\w$]+$/.exec(item);
+    if (asMatch)
+      into.push(asMatch[1]);
+    else if (/^[\w$]+$/.test(item) || item === "default")
+      into.push(item);
+  }
+}
+function parseClause(raw) {
+  const clause = raw.trim();
+  const result = { named: [] };
+  if (clause.startsWith("type ") || clause.startsWith("*"))
+    return result;
+  if (clause.startsWith("{")) {
+    parseNamedList(clause, result.named);
+    return result;
+  }
+  const match = /^([\w$]+)\s*(?:,\s*([\s\S]+))?$/.exec(clause);
+  if (!match)
+    return result;
+  result.named.push("default");
+  const trailing = match[2]?.trim();
+  if (trailing?.startsWith("{"))
+    parseNamedList(trailing, result.named);
+  return result;
+}
+function missingExportMessage(target, name, specifier) {
+  return `"${target}" has no export "${name}" (imported as "${specifier}"); Burger provides: ${BURGER_EXPORTS[target].join(", ")}`;
+}
+function scanBurgerImports(code) {
+  const messages = [];
+  const reported = new Set;
+  for (const match of code.matchAll(IMPORT_OR_REEXPORT)) {
+    const specifier = match[2];
+    const specifierClass = classifySpecifier(specifier);
+    if (specifierClass.kind !== "burger")
+      continue;
+    const target = specifierClass.target;
+    for (const name of parseClause(match[1]).named) {
+      const provided = name === "default" ? target in BURGER_DEFAULT_EXPORT : BURGER_EXPORTS[target].includes(name);
+      const key = `${target}\x00${name}\x00${specifier}`;
+      if (provided || reported.has(key))
+        continue;
+      reported.add(key);
+      messages.push(missingExportMessage(target, name, specifier));
+    }
+  }
+  return messages;
+}
+var NATIVE_LOADER_PACKAGE = /[\\/]node_modules[\\/](?:bindings|node-gyp-build)[\\/]/;
+function metafileKeyToPath(key, cwd) {
+  if (isAbsolute(key))
+    return key;
+  const colon = key.indexOf(":");
+  const slash = key.indexOf("/");
+  if (colon > 0 && (slash === -1 || colon < slash))
+    return key;
+  return resolve(cwd, key);
+}
+function importerGraph(metafile, cwd) {
+  const parents = new Map;
+  for (const [key, input] of Object.entries(metafile.inputs)) {
+    const importer = metafileKeyToPath(key, cwd);
+    for (const record of input.imports) {
+      if (record.external)
+        continue;
+      const child = metafileKeyToPath(record.path, cwd);
+      if (child !== importer && !parents.has(child)) {
+        parents.set(child, importer);
+      }
+    }
+  }
+  return parents;
+}
+function importerChain(file, parents) {
+  const chain = [file];
+  const seen = new Set(chain);
+  let current = parents.get(file);
+  while (current !== undefined && !seen.has(current)) {
+    chain.unshift(current);
+    seen.add(current);
+    current = parents.get(current);
+  }
+  return chain;
+}
+function loaderFor(file) {
+  switch (extname(file)) {
+    case ".ts":
+    case ".mts":
+    case ".cts":
+      return "ts";
+    case ".tsx":
+      return "tsx";
+    case ".jsx":
+      return "jsx";
+    case ".js":
+    case ".mjs":
+    case ".cjs":
+      return "js";
+    default:
+      return;
+  }
+}
+function codeOf(file, source) {
+  const loader = loaderFor(file);
+  if (!loader)
+    return;
+  try {
+    return new Bun.Transpiler({ loader }).transformSync(source);
+  } catch {
+    return source;
+  }
+}
+function scanModule(file, code, importedSpecifiers) {
+  const messages = [];
+  if (BUN_GLOBAL.test(code)) {
+    messages.push("uses the Bun global (Bun.*), which does not exist in Burger");
+  }
+  if (IMPORT_META_PATH.test(code) && importedSpecifiers.some((specifier) => FS_SPECIFIERS.has(specifier))) {
+    messages.push("reads files relative to import.meta; bundling moves this module, so the files are not found at runtime \u2014 import the data statically instead");
+  }
+  if (NATIVE_LOADER_PACKAGE.test(file)) {
+    messages.push("loads a native addon (bindings/node-gyp-build), which Burger cannot run");
+  }
+  messages.push(...scanBurgerImports(code));
+  return messages;
+}
+function collectProblems(metafile, violations, cwd) {
+  const parents = importerGraph(metafile, cwd);
+  const problems = [];
+  for (const violation of violations) {
+    problems.push({
+      message: `import "${violation.specifier}": ${violation.reason}`,
+      chain: importerChain(violation.importer, parents)
+    });
+  }
+  for (const [key, input] of Object.entries(metafile.inputs)) {
+    const file = metafileKeyToPath(key, cwd);
+    if (!isAbsolute(file))
+      continue;
+    let source;
+    try {
+      source = readFileSync(file, "utf8");
+    } catch {
+      continue;
+    }
+    const code = codeOf(file, source);
+    if (code === undefined)
+      continue;
+    const specifiers = input.imports.flatMap((record) => record.original === undefined ? [record.path] : [record.path, record.original]);
+    for (const message of scanModule(file, code, specifiers)) {
+      problems.push({ message, chain: importerChain(file, parents) });
+    }
+  }
+  return problems;
+}
+function formatProblems(problems, cwd) {
+  const lines = [`burger-build: ${problems.length} problem(s) \u2014 this code cannot run on Burger:`];
+  for (const problem of problems) {
+    lines.push(`  \u2717 ${problem.message}`);
+    problem.chain.forEach((file, index) => {
+      const shown = isAbsolute(file) ? relative(cwd, file) : file;
+      lines.push(index === 0 ? `      ${shown}` : `      \u2192 ${shown}`);
+    });
+  }
+  return lines.join(`
+`);
+}
+
 // ../burger-build/src/plugin.ts
 var BRIDGE_NAMESPACE = "burger-require";
 var BRIDGE_PREFIX = "cjs-bridge/";
@@ -509,22 +589,36 @@ function relativeSpecifier(fromDir, to) {
   const rel = relative2(fromDir, to).split(sep).join("/");
   return rel.startsWith(".") ? rel : `./${rel}`;
 }
+var JS_TO_TS_SUFFIXES = {
+  ".js": [".ts", ".tsx"],
+  ".jsx": [".tsx"],
+  ".mjs": [".mts"],
+  ".cjs": []
+};
 function resolveRelativeFile(importerDir, specifier) {
   const base = resolve2(importerDir, specifier);
+  const isFile = (candidate) => existsSync(candidate) && statSync(candidate).isFile();
+  if (isFile(base))
+    return base;
+  const mapped = JS_TO_TS_SUFFIXES[extname2(specifier)];
+  if (mapped !== undefined) {
+    const stem = base.slice(0, base.length - extname2(specifier).length);
+    return mapped.map((suffix) => stem + suffix).find(isFile);
+  }
   const candidates = [
-    base,
     ...RESOLVE_SUFFIXES.map((suffix) => base + suffix),
     ...RESOLVE_SUFFIXES.map((suffix) => join2(base, `index${suffix}`))
   ];
-  return candidates.find((candidate) => existsSync(candidate) && statSync(candidate).isFile());
+  return candidates.find(isFile);
 }
 function dependencyFileName(specifier) {
   return specifier.replace(/^@/, "").replace(/[\\/]/g, "__") + ".js";
 }
+var TEXT_NAMESPACE = "burger-text";
 function rewriteSpecifier(ws, importer, specifier) {
   const specifierClass = classifySpecifier(specifier);
   if (specifierClass.kind === "burger")
-    return specifierClass.target;
+    return { external: specifierClass.target };
   if (specifierClass.kind === "forbidden") {
     ws.problems.push({ message: `import "${specifier}": ${specifierClass.reason}`, chain: [importer] });
     return;
@@ -541,7 +635,14 @@ function rewriteSpecifier(ws, importer, specifier) {
         return;
       }
       ws.jsonFiles.add(target);
-      return `${relativeSpecifier(dirname(importer), target)}.js`;
+      return { external: `${relativeSpecifier(dirname(importer), target)}.js` };
+    }
+    if (!isCodeFile(target)) {
+      if (!isInside(target, ws.root)) {
+        ws.problems.push({ message: `"${specifier}" is outside ${ws.root}`, chain: [importer] });
+        return;
+      }
+      return { inline: target };
     }
     if (!ws.sources.has(target)) {
       ws.problems.push({
@@ -550,7 +651,7 @@ function rewriteSpecifier(ws, importer, specifier) {
       });
       return;
     }
-    return preparedPath(relativeSpecifier(dirname(importer), target));
+    return { external: preparedPath(relativeSpecifier(dirname(importer), target)) };
   }
   if (specifier.startsWith("#")) {
     ws.problems.push({
@@ -560,7 +661,7 @@ function rewriteSpecifier(ws, importer, specifier) {
     return;
   }
   ws.dependencies.add(specifier);
-  return specifier;
+  return { external: specifier };
 }
 function moduleIdentity(importer, specifier) {
   const specifierClass = classifySpecifier(specifier);
@@ -604,8 +705,17 @@ function sourcesPlugin(ws) {
           });
           return { path: args.path, external: true };
         }
-        return { path: rewriteSpecifier(ws, args.importer, args.path) ?? args.path, external: true };
+        const resolved = rewriteSpecifier(ws, args.importer, args.path);
+        if (resolved === undefined)
+          return { path: args.path, external: true };
+        if ("inline" in resolved)
+          return { path: resolved.inline, namespace: TEXT_NAMESPACE, external: false };
+        return { path: resolved.external, external: true };
       });
+      build.onLoad({ filter: /.*/, namespace: TEXT_NAMESPACE }, (args) => ({
+        contents: readFileSync2(args.path, "utf8"),
+        loader: "text"
+      }));
     }
   };
 }
@@ -730,7 +840,8 @@ async function prepareTests(options) {
     const output = join2(out, preparedPath(relative2(root, file)));
     const prepared = readFileSync2(output, "utf8").replace(MOCK_MODULE_CALL, (call, quote, specifier) => {
       const rewritten = rewriteSpecifier(ws, file, specifier);
-      return rewritten === undefined ? call : call.replace(`${quote}${specifier}${quote}`, JSON.stringify(rewritten));
+      const replacement = rewritten === undefined ? undefined : ("external" in rewritten) ? rewritten.external : undefined;
+      return replacement === undefined ? call : call.replace(`${quote}${specifier}${quote}`, JSON.stringify(replacement));
     });
     writeFileSync2(output, prepared);
     const source = readFileSync2(file, "utf8");

package/dist/burger-build/test-prepare.d.ts

@@ -42,12 +42,19 @@ interface Workspace {
     dependencies: Set<string>;
     problems: Problem[];
 }
+/** Namespace `sourcesPlugin` uses for a non-code, non-JSON file inlined as text (matching Bun's own `build`). */
+export declare const TEXT_NAMESPACE = "burger-text";
+export type ResolvedImport = {
+    external: string;
+} | {
+    inline: string;
+};
 /**
  * What a prepared module imports instead of `specifier` (written in
  * `importer`). Returns undefined — with a recorded problem — when the import
  * cannot work under Burger.
  */
-export declare function rewriteSpecifier(ws: Workspace, importer: string, specifier: string): string | undefined;
+export declare function rewriteSpecifier(ws: Workspace, importer: string, specifier: string): ResolvedImport | undefined;
 /**
  * Problems for a module that statically imports a module it also replaces
  * with `mock.module`. Bun patches the already-linked bindings, so the test

package/dist/burger-types/globals.d.ts

@@ -64,3 +64,48 @@ interface BurgerProcess {
   memoryUsage(): BurgerProcessMemoryUsage;
 }
 declare var process: BurgerProcess;
+
+/** A message delivered to a `Worker` or to a worker's own scope. Data is copied as JSON. */
+interface BurgerWorkerMessageEvent {
+  readonly type: "message";
+  readonly data: unknown;
+  readonly target: unknown;
+}
+
+/** An error a worker's handler threw, reported to its parent. */
+interface BurgerWorkerErrorEvent {
+  readonly type: "error";
+  readonly message: string;
+  readonly error: Error;
+  readonly target: unknown;
+}
+
+/**
+ * The Worker-equivalent (data-app pack, econ-v1/node-app-burger#12): the Web
+ * `Worker` as Bun provides it, limited to running work an app can cancel.
+ * `specifier` is a path, a `file:` URL string, or an object with a `file:`
+ * `href`.
+ */
+declare class Worker {
+  constructor(specifier: string | { readonly href: string }, options?: { type?: "module" });
+  postMessage(message: unknown): void;
+  terminate(): void;
+  onmessage: ((event: BurgerWorkerMessageEvent) => void) | null;
+  onerror: ((event: BurgerWorkerErrorEvent) => void) | null;
+  addEventListener(type: "message", listener: (event: BurgerWorkerMessageEvent) => void): void;
+  addEventListener(type: "error", listener: (event: BurgerWorkerErrorEvent) => void): void;
+  removeEventListener(type: "message" | "error", listener: (...args: never[]) => void): void;
+}
+
+/**
+ * Inside a worker module (data-app pack): the worker's own scope, where
+ * `self` is `globalThis`. A handler that throws is reported to the parent's
+ * `onerror` and the worker keeps running.
+ */
+declare function postMessage(message: unknown): void;
+/** Ends this worker from inside. */
+declare function close(): void;
+declare var onmessage: ((event: BurgerWorkerMessageEvent) => void) | null;
+declare function addEventListener(type: "message", listener: (event: BurgerWorkerMessageEvent) => void): void;
+declare function removeEventListener(type: "message", listener: (event: BurgerWorkerMessageEvent) => void): void;
+declare var self: typeof globalThis;

package/dist/burger-types/modules.d.ts

@@ -47,13 +47,40 @@ declare module "burger:fs" {
     readonly mtimeMs: number;
   }
 
+  /**
+   * A `readdirSync(path, { withFileTypes: true })` entry, Node 22 shape (data-app
+   * pack). The type is the entry's own, symlinks not followed.
+   */
+  export class Dirent {
+    private constructor();
+    readonly name: string;
+    /** The directory it was listed from, as the caller spelled it. */
+    readonly parentPath: string;
+    /** Same as `parentPath`; Node's older name for it, kept by the runtime for code that reads it. */
+    readonly path: string;
+    isFile(): boolean;
+    isDirectory(): boolean;
+    isSymbolicLink(): boolean;
+    isFIFO(): boolean;
+    isSocket(): boolean;
+    isBlockDevice(): boolean;
+    isCharacterDevice(): boolean;
+  }
+
+  export interface ReaddirOptions {
+    encoding?: Utf8Encoding;
+    /** Names (or Dirents) of every entry below, as paths relative to the listed directory. */
+    recursive?: boolean;
+  }
+
   export function existsSync(path: PathLike): boolean;
   export function readFileSync(path: PathLike): Uint8Array;
   export function readFileSync(path: PathLike, encoding: Utf8Encoding | { encoding: Utf8Encoding }): string;
   export function writeFileSync(path: PathLike, data: string | Uint8Array): void;
   export function appendFileSync(path: PathLike, data: string | Uint8Array): void;
   export function mkdirSync(path: PathLike, options?: { recursive?: boolean }): void;
-  export function readdirSync(path: PathLike): string[];
+  export function readdirSync(path: PathLike, options?: Utf8Encoding | (ReaddirOptions & { withFileTypes?: false })): string[];
+  export function readdirSync(path: PathLike, options: ReaddirOptions & { withFileTypes: true }): Dirent[];
   export function statSync(path: PathLike): Stats;
   export function rmSync(path: PathLike, options?: { recursive?: boolean; force?: boolean }): void;
   export function renameSync(oldPath: PathLike, newPath: PathLike): void;
@@ -61,6 +88,39 @@ declare module "burger:fs" {
   export function unlinkSync(path: PathLike): void;
   /** Create a unique directory whose name starts with `prefix`; returns its path. */
   export function mkdtempSync(prefix: string): string;
+  // data-app pack (econ-v1/node-app-burger#12):
+  export interface RealpathSync {
+    (path: PathLike, options?: Utf8Encoding | { encoding: Utf8Encoding }): string;
+    /** The same resolver (Node's name for it). */
+    native(path: PathLike, options?: Utf8Encoding | { encoding: Utf8Encoding }): string;
+  }
+  export const realpathSync: RealpathSync;
+  /** `copyFileSync` modes and `access`-style mode bits. `COPYFILE_FICLONE` falls back to a plain copy. */
+  export const constants: {
+    readonly COPYFILE_EXCL: 1;
+    readonly COPYFILE_FICLONE: 2;
+    readonly COPYFILE_FICLONE_FORCE: 4;
+    readonly F_OK: 0;
+    readonly R_OK: 4;
+    readonly W_OK: 2;
+    readonly X_OK: 1;
+  };
+  export function copyFileSync(src: PathLike, dest: PathLike, mode?: number): void;
+  /** `type` ("file"/"dir"/"junction") matters only on Windows and is ignored. */
+  export function symlinkSync(target: PathLike, path: PathLike, type?: "file" | "dir" | "junction"): void;
+  export type OpenFlags = "r" | "r+" | "rs+" | "w" | "wx" | "w+" | "wx+" | "a" | "ax" | "a+" | "ax+";
+  export function openSync(path: PathLike, flags?: OpenFlags, mode?: number | string): number;
+  export function writeSync(fd: number, buffer: Uint8Array, offset?: number, length?: number, position?: number | null): number;
+  export function writeSync(fd: number, text: string, position?: number | null, encoding?: Utf8Encoding): number;
+  export function fsyncSync(fd: number): void;
+  export function fdatasyncSync(fd: number): void;
+  export function closeSync(fd: number): void;
+  // second data-app pack (econ-v1/node-app-memory#40):
+  /** Read into `buffer` at `offset`; `position` null reads from the current position. Returns bytes read. */
+  export function readSync(fd: number, buffer: Uint8Array, offset?: number, length?: number, position?: number | null): number;
+  export function fstatSync(fd: number): Stats;
+  /** Set access and modification times (seconds since the epoch, or Dates). */
+  export function utimesSync(path: PathLike, atime: number | Date, mtime: number | Date): void;
 
   export interface FsPromises {
     exists(path: PathLike): Promise<boolean>;
@@ -69,7 +129,8 @@ declare module "burger:fs" {
     writeFile(path: PathLike, data: string | Uint8Array): Promise<void>;
     appendFile(path: PathLike, data: string | Uint8Array): Promise<void>;
     mkdir(path: PathLike, options?: { recursive?: boolean }): Promise<void>;
-    readdir(path: PathLike): Promise<string[]>;
+    readdir(path: PathLike, options?: Utf8Encoding | (ReaddirOptions & { withFileTypes?: false })): Promise<string[]>;
+    readdir(path: PathLike, options: ReaddirOptions & { withFileTypes: true }): Promise<Dirent[]>;
     stat(path: PathLike): Promise<Stats>;
     rm(path: PathLike, options?: { recursive?: boolean; force?: boolean }): Promise<void>;
     rename(oldPath: PathLike, newPath: PathLike): Promise<void>;
@@ -93,6 +154,19 @@ declare module "burger:fs" {
     chmodSync: typeof chmodSync;
     unlinkSync: typeof unlinkSync;
     mkdtempSync: typeof mkdtempSync;
+    realpathSync: typeof realpathSync;
+    constants: typeof constants;
+    copyFileSync: typeof copyFileSync;
+    symlinkSync: typeof symlinkSync;
+    openSync: typeof openSync;
+    writeSync: typeof writeSync;
+    fsyncSync: typeof fsyncSync;
+    fdatasyncSync: typeof fdatasyncSync;
+    closeSync: typeof closeSync;
+    readSync: typeof readSync;
+    fstatSync: typeof fstatSync;
+    utimesSync: typeof utimesSync;
+    Dirent: typeof Dirent;
     promises: FsPromises;
   };
   export default fs;
@@ -222,7 +296,7 @@ declare module "burger:crypto" {
 }
 
 declare module "burger:buffer" {
-  export type BufferEncoding = "utf8" | "utf-8" | "hex" | "base64" | "base64url";
+  export type BufferEncoding = "utf8" | "utf-8" | "hex" | "base64" | "base64url" | "latin1" | "binary" | "ascii";
 
   /** C5 subset of Node's Buffer. Instances are `Uint8Array`s. */
   export interface Buffer extends Uint8Array<ArrayBuffer> {
@@ -265,21 +339,43 @@ declare module "burger:sqlite" {
     get(...params: SQLParams): Row | null;
     run(...params: SQLParams): Changes;
     values(...params: SQLParams): SQLValue[][];
+    /** data-app pack: rows one at a time; the deadline bounds the whole iteration. */
+    iterate(...params: SQLParams): IterableIterator<Row>;
+    [Symbol.iterator](): IterableIterator<Row>;
+    /** data-app pack. */
+    readonly columnNames: string[];
+    /**
+     * data-app pack (Burger extension): wall-clock budget in ms for each
+     * execution of this statement. Past it the call throws an Error whose
+     * `code` is "SQLITE_INTERRUPT"; unlike the runtime watchdog it is not a
+     * strike. `undefined` inherits the Database's `deadlineMs`; 0 or `null`
+     * means none.
+     */
+    deadlineMs: number | null | undefined;
   }
 
   export interface DatabaseOptions {
     create?: boolean;
     readonly?: boolean;
+    readwrite?: boolean;
+    /** data-app pack: the default `deadlineMs` of this database's statements. */
+    deadlineMs?: number;
   }
 
   export class Database {
     constructor(filename?: string, options?: DatabaseOptions);
+    /** data-app pack: the default statement deadline in ms (`undefined`: none). */
+    deadlineMs: number | null | undefined;
     query<Row = unknown>(sql: string): Statement<Row>;
     prepare<Row = unknown>(sql: string): Statement<Row>;
     exec(sql: string, ...params: SQLParams): Changes;
     run(sql: string, ...params: SQLParams): Changes;
     transaction<Args extends unknown[], Result>(fn: (...args: Args) => Result): (...args: Args) => Result;
     close(): void;
+    /** data-app pack: the database image (`sqlite3_serialize`) of schema `name` (default "main"). */
+    serialize(name?: string): Uint8Array;
+    /** second data-app pack: open an in-memory database from `serialize()` bytes. */
+    static deserialize(serialized: Uint8Array, isReadOnly?: boolean): Database;
   }
 
   /** Default export is the Database class itself, which also carries `.Database` (C6). */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@econ-v1/app-sdk",
-  "version": "7.4.0",
+  "version": "7.4.2",
   "description": "TypeScript SDK for building Node mini-app plugins (Bun runtime) on the Lightning-powered marketplace daemon",
   "license": "MIT OR Apache-2.0",
   "author": "Node contributors",