@folienbaukasten/extension-toolkit 1.0.0

package/dist/fbk-pack.js

@@ -0,0 +1,756 @@
+#!/usr/bin/env node
+
+// toolkit/bin/fbk-pack.ts
+import path6 from "node:path";
+
+// toolkit/src/abi.ts
+import { existsSync, readFileSync } from "node:fs";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+var ABI_DIR = path.resolve(import.meta.dirname, "../abi");
+var abi = JSON.parse(
+  readFileSync(path.join(ABI_DIR, "abi.json"), "utf8")
+);
+var provenance = existsSync(
+  path.join(ABI_DIR, "provenance.json")
+) ? JSON.parse(readFileSync(path.join(ABI_DIR, "provenance.json"), "utf8")) : { app: "unknown", commit: "unknown", emittedAt: "unknown" };
+var packFormat = await import(pathToFileURL(path.join(ABI_DIR, "pack.js")).href);
+var SHIMS = path.join(ABI_DIR, "shims");
+
+// toolkit/src/pack.ts
+import { Ajv } from "ajv";
+import { build } from "esbuild";
+import JSZip from "jszip";
+import { createGenerator } from "ts-json-schema-generator";
+import { createHash, createPrivateKey, sign as signBytes } from "node:crypto";
+import { existsSync as existsSync4, mkdirSync, readFileSync as readFileSync4, readdirSync, rmSync, writeFileSync } from "node:fs";
+import path4 from "node:path";
+
+// toolkit/src/config.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "node:fs";
+import path2 from "node:path";
+function readExtension(target, overrides2 = {}) {
+  const dir = path2.resolve(target);
+  if (!existsSync2(path2.join(dir, "index.ts"))) {
+    throw new Error(
+      `no extension at ${dir}: an extension is a directory with an index.ts that default-exports a ComponentSet.`
+    );
+  }
+  const configFile = path2.join(dir, "pack.json");
+  const config = existsSync2(configFile) ? JSON.parse(readFileSync2(configFile, "utf8")) : {};
+  const merged = { ...config, ...overrides2 };
+  const id = merged.id ?? path2.basename(dir);
+  const provides = merged.provides ?? (merged.components?.length ? ["theme", "components"] : ["theme"]);
+  const cssFile = path2.join(dir, "theme.css");
+  return {
+    dir,
+    config: merged,
+    id,
+    version: merged.version ?? "1.0.0",
+    provides,
+    providesTheme: provides.includes("theme"),
+    themeCss: existsSync2(cssFile) ? readFileSync2(cssFile, "utf8") : null
+  };
+}
+
+// toolkit/src/check.ts
+import { existsSync as existsSync3, readFileSync as readFileSync3, statSync } from "node:fs";
+import path3 from "node:path";
+import { pathToFileURL as pathToFileURL2 } from "node:url";
+var MAX_GLYPH_BYTES = 16384;
+function emptyFindings() {
+  return { errors: [], warnings: [] };
+}
+function merge(into, from) {
+  into.errors.push(...from.errors);
+  into.warnings.push(...from.warnings);
+  return into;
+}
+function definedTokens(css) {
+  return new Set([...css.matchAll(/(--[a-z0-9-]+)\s*:/gi)].map((m) => m[1]));
+}
+function definesBoxStyle(css, cls) {
+  return new RegExp(`\\.${cls}(?![-\\w])[^{]*\\{`).test(css);
+}
+function checkTheme(ext) {
+  const out = emptyFindings();
+  if (!ext.providesTheme) {
+    if (ext.themeCss) {
+      out.errors.push(
+        "this pack provides no theme but has a theme.css. The loader links a stylesheet only for a pack that provides a theme, so it would ship and never load. Style from the platform tokens instead \u2014 every theme defines them."
+      );
+    }
+    return out;
+  }
+  if (!ext.themeCss) {
+    out.errors.push("a theme needs a theme.css, imported from index.ts");
+    return out;
+  }
+  const defined = definedTokens(ext.themeCss);
+  const missing = abi.requiredTokens.filter((t) => !defined.has(t));
+  if (missing.length > 0) {
+    out.errors.push(
+      `theme.css is missing ${missing.length} platform token(s): ${missing.join(", ")}
+  \u2192 the platform reads these without a fallback. Copy a working theme.css and change its values rather than assembling one.`
+    );
+  }
+  const missingStyles = abi.requiredBoxStyles.filter((cls) => !definesBoxStyle(ext.themeCss, cls));
+  if (missingStyles.length > 0) {
+    out.errors.push(
+      `theme.css is missing required box styles: ${missingStyles.map((c) => `.${c}`).join(", ")}
+  \u2192 base.css owns the box structure; each theme owns the look, and an undefined style renders an unstyled box rather than failing.`
+    );
+  }
+  const missingSwatch = Object.entries(abi.swatchTokens).filter(([, token]) => !new RegExp(`${token}:\\s*[^;]+;`).test(ext.themeCss)).map(([, token]) => token);
+  if (missingSwatch.length > 0) {
+    out.warnings.push(
+      `no swatch could be read (${missingSwatch.join(", ")} not found), so the theme chooser will show it without its palette`
+    );
+  }
+  return out;
+}
+function checkGlyph(ext, kind, rel) {
+  const out = emptyFindings();
+  const file = path3.join(ext.dir, rel);
+  if (!rel.endsWith(".svg") || !existsSync3(file)) {
+    out.errors.push(`component '${kind}': glyph '${rel}' is not an .svg file here`);
+    return out;
+  }
+  const bytes = statSync(file).size;
+  if (bytes > MAX_GLYPH_BYTES) {
+    out.errors.push(
+      `component '${kind}': glyph is ${bytes} bytes; the limit is ${MAX_GLYPH_BYTES}. It is a diagram on a card, not an illustration.`
+    );
+  }
+  if (!/^\s*(<\?xml|<!--|<svg)/.test(readFileSync3(file, "utf8"))) {
+    out.errors.push(`component '${kind}': glyph is not SVG`);
+  }
+  return out;
+}
+function checkManifest(manifest) {
+  const out = emptyFindings();
+  for (const problem of packFormat.manifestProblems(manifest, abi.builtInSetIds)) {
+    out.errors.push(problem);
+  }
+  if (manifest.platformAbi !== abi.platformAbi) {
+    out.errors.push(
+      `this pack declares platform ABI ${manifest.platformAbi}, the bundle provides ${abi.platformAbi}`
+    );
+  }
+  return out;
+}
+async function inspectSet(bundle) {
+  const anything = new Proxy(function stub() {
+  }, {
+    get: (_t, prop) => prop === "default" ? anything : anything,
+    apply: () => anything,
+    construct: () => anything
+  });
+  globalThis.__FBK_SET_RUNTIME__ = {
+    react: anything,
+    jsxRuntime: anything,
+    platform: anything
+  };
+  try {
+    const mod = await import(`${pathToFileURL2(path3.resolve(bundle)).href}?t=${Date.now()}`);
+    const set = mod.default;
+    if (!set) return null;
+    const components = Object.entries(set.components ?? {});
+    return {
+      id: set.id,
+      components: components.map(([kind]) => kind),
+      webOnly: components.filter(([, def]) => def?.webOnly).map(([kind]) => kind),
+      hasChrome: typeof set.chrome === "object" && set.chrome !== null
+    };
+  } catch {
+    return null;
+  } finally {
+    delete globalThis.__FBK_SET_RUNTIME__;
+  }
+}
+function checkRegistration(ext, set, declared) {
+  const out = emptyFindings();
+  if (!set) {
+    out.warnings.push(
+      "index.ts could not be inspected, so pack.json's component list was not checked against the set that will actually load"
+    );
+    return out;
+  }
+  if (set.id && set.id !== ext.id) {
+    out.errors.push(
+      `index.ts exports id '${set.id}' but this pack publishes as '${ext.id}'. The id is the namespace of every component kind and the value a deck records \u2014 they must match.`
+    );
+  }
+  const declaredKinds = declared.map((c) => c.kind);
+  const unregistered = declaredKinds.filter((k) => !set.components.includes(k));
+  if (unregistered.length > 0) {
+    out.errors.push(
+      `pack.json declares component(s) index.ts does not register: ${unregistered.join(", ")}
+  \u2192 the app would offer the slide type and then blank the slide's body.`
+    );
+  }
+  const undeclared = set.components.filter((k) => !declaredKinds.includes(k));
+  if (undeclared.length > 0) {
+    out.errors.push(
+      `index.ts registers component(s) pack.json does not declare: ${undeclared.join(", ")}
+  \u2192 undeclared components have no description, schema or glyph, so the model never writes them and the components view cannot show them.`
+    );
+  }
+  for (const c of declared) {
+    const codeSaysWebOnly = set.webOnly.includes(c.kind);
+    if (Boolean(c.webOnly) !== codeSaysWebOnly) {
+      out.errors.push(
+        `component '${c.kind}': webOnly is ${String(Boolean(c.webOnly))} in pack.json but ${String(codeSaysWebOnly)} in index.ts.
+  \u2192 the app reads pack.json. A web-only component declared PPTX-safe exports as a silently blank region.`
+      );
+    }
+  }
+  if (ext.providesTheme && !set.hasChrome) {
+    out.errors.push(
+      "this pack provides a theme but index.ts exports no chrome \u2014 a theme owns the header and footer of every content slide"
+    );
+  }
+  return out;
+}
+function checkIntent(ext) {
+  const out = emptyFindings();
+  if (ext.providesTheme && !ext.config.production) {
+    out.warnings.push(
+      `'${ext.id}' is not marked production: true \u2014 the installed theme appears in the Installed list but not in the theme chooser, so nobody can pick it`
+    );
+  }
+  if (!ext.config.publisher) {
+    out.warnings.push("no publisher \u2014 the install dialog will have no name to show");
+  }
+  return out;
+}
+
+// toolkit/src/pack.ts
+function swatchOf(css) {
+  if (!css) return void 0;
+  const values = {};
+  for (const [key, token] of Object.entries(abi.swatchTokens)) {
+    const m = css.match(new RegExp(`${token}:\\s*([^;]+);`));
+    if (!m) return void 0;
+    values[key] = m[1].trim();
+  }
+  return values;
+}
+function componentMetas(ext, findings) {
+  return (ext.config.components ?? []).map((c) => {
+    const meta = { ...c };
+    delete meta.schemaType;
+    if (c.glyph) merge(findings, checkGlyph(ext, c.kind, c.glyph));
+    if (!c.schemaType) {
+      if (c.example !== void 0) {
+        findings.warnings.push(
+          `component '${c.kind}': an example without a schemaType is unchecked, and the model is shown props it cannot validate against a type`
+        );
+      }
+      return meta;
+    }
+    const componentsTs = path4.join(ext.dir, "components.ts");
+    if (!existsSync4(componentsTs)) {
+      findings.errors.push(
+        `component '${c.kind}': schemaType '${c.schemaType}' needs a components.ts to be generated from`
+      );
+      return meta;
+    }
+    const setTsconfig = path4.join(ext.dir, "tsconfig.json");
+    if (!existsSync4(setTsconfig)) {
+      findings.errors.push(
+        "an extension needs a tsconfig.json (extend the toolkit's tsconfig.extension.json) \u2014 the prop schemas are generated by compiling components.ts against it"
+      );
+      return meta;
+    }
+    try {
+      meta.schema = createGenerator({
+        path: componentsTs,
+        tsconfig: setTsconfig,
+        type: c.schemaType,
+        expose: "export",
+        jsDoc: "extended",
+        topRef: false,
+        skipTypeCheck: true
+      }).createSchema(c.schemaType);
+    } catch (error) {
+      findings.errors.push(
+        `component '${c.kind}': could not generate a schema for '${c.schemaType}' \u2014 ${error instanceof Error ? error.message : String(error)}`
+      );
+      return meta;
+    }
+    if (c.example !== void 0) {
+      const validate = new Ajv({ strict: false, allErrors: true }).compile(meta.schema);
+      if (!validate(c.example)) {
+        const why = (validate.errors ?? []).map((e) => `${e.instancePath || "(root)"} ${e.message}`).join("; ");
+        findings.errors.push(`component '${c.kind}': example does not match its schema: ${why}`);
+      }
+    }
+    return meta;
+  });
+}
+async function checkExtension(target, overrides2 = {}) {
+  const ext = readExtension(target, overrides2);
+  const findings = emptyFindings();
+  merge(findings, checkTheme(ext));
+  merge(findings, checkIntent(ext));
+  const metas = componentMetas(ext, findings);
+  const manifest = manifestOf(ext, metas, []);
+  merge(findings, checkManifest(manifest));
+  const tmp = path4.join(ext.dir, `.fbk-check-${process.pid}.mjs`);
+  try {
+    await bundleSet(ext, tmp);
+    merge(findings, checkRegistration(ext, await inspectSet(tmp), ext.config.components ?? []));
+  } catch (error) {
+    findings.errors.push(
+      `index.ts does not build: ${error instanceof Error ? error.message : String(error)}`
+    );
+  } finally {
+    rmSync(tmp, { force: true });
+    rmSync(`${tmp.replace(/\.mjs$/, "")}.css`, { force: true });
+  }
+  return { ext, findings, manifest };
+}
+async function bundleSet(ext, outfile) {
+  await build({
+    entryPoints: [path4.join(ext.dir, "index.ts")],
+    outfile,
+    bundle: true,
+    format: "esm",
+    target: "es2022",
+    jsx: "automatic",
+    minify: true,
+    plugins: [
+      {
+        /*
+         * A root-relative url() in a theme's CSS — /fonts/poppins-400.woff2,
+         * /logo.png — names a file the APP serves, not one to copy into the
+         * pack. Left as-is it resolves at render time against whatever
+         * origin the renderer is on.
+         *
+         * A plugin rather than `external: ['/*']`: esbuild tests external
+         * patterns against resolved absolute paths too, so that pattern also
+         * externalised `./theme.css` and the pack came out with no
+         * stylesheet. The existsSync guard is what keeps a real absolute
+         * path (the shims below) resolving normally.
+         */
+        name: "app-served-urls",
+        setup(build2) {
+          build2.onResolve(
+            { filter: /^\// },
+            (args) => existsSync4(args.path) ? null : { path: args.path, external: true }
+          );
+        }
+      }
+    ],
+    alias: {
+      react: path4.join(SHIMS, "react.js"),
+      "react/jsx-runtime": path4.join(SHIMS, "jsx-runtime.js"),
+      "react/jsx-dev-runtime": path4.join(SHIMS, "jsx-runtime.js"),
+      "@folienbaukasten/platform": path4.join(SHIMS, "platform.js")
+    },
+    logLevel: "warning"
+  });
+}
+function manifestOf(ext, metas, templates) {
+  const swatch = swatchOf(ext.themeCss);
+  const c = ext.config;
+  return {
+    formatVersion: abi.packFormatVersion,
+    id: ext.id,
+    name: c.name ?? ext.id,
+    ...c.description ? { description: c.description } : {},
+    version: ext.version,
+    platformAbi: abi.platformAbi,
+    ...c.publisher ? { publisher: c.publisher } : {},
+    ...c.production ? { production: true } : {},
+    ...swatch ? { swatch } : {},
+    ...templates.length ? { templates } : {},
+    ...c.layoutDescriptions ? { layoutDescriptions: c.layoutDescriptions } : {},
+    ...ext.provides.length === 1 && ext.provides[0] === "theme" ? {} : { provides: ext.provides },
+    ...metas.length ? { components: metas } : {},
+    ...c.pptxSafe === false ? { pptxSafe: false } : {}
+  };
+}
+async function packExtension(target, opts) {
+  const ext = readExtension(target, opts.overrides);
+  const outDir = path4.resolve(opts.outDir);
+  const findings = emptyFindings();
+  merge(findings, checkTheme(ext));
+  merge(findings, checkIntent(ext));
+  const metas = componentMetas(ext, findings);
+  const stage = path4.join(outDir, `.${ext.id}-stage`);
+  rmSync(stage, { recursive: true, force: true });
+  mkdirSync(stage, { recursive: true });
+  await bundleSet(ext, path4.join(stage, "set.js"));
+  const stylesheet = path4.join(stage, "set.css");
+  if (ext.providesTheme && !existsSync4(stylesheet)) {
+    findings.errors.push("this theme produced no stylesheet \u2014 index.ts must import its theme.css");
+  }
+  if (!ext.providesTheme && existsSync4(stylesheet)) {
+    findings.errors.push(
+      "this pack provides no theme but imported a stylesheet; a components-only pack's set.css would never be linked. Style from the platform tokens instead."
+    );
+  }
+  const probe = path4.join(stage, ".probe.mjs");
+  writeFileSync(probe, readFileSync4(path4.join(stage, "set.js")));
+  merge(findings, checkRegistration(ext, await inspectSet(probe), ext.config.components ?? []));
+  rmSync(probe, { force: true });
+  const templates = [];
+  const templateDir = path4.join(ext.dir, "templates");
+  if (existsSync4(templateDir)) {
+    mkdirSync(path4.join(stage, "templates"), { recursive: true });
+    for (const file2 of readdirSync(templateDir).filter((f) => f.endsWith(".json")).sort()) {
+      const id = path4.basename(file2, ".json");
+      const deck = JSON.parse(readFileSync4(path4.join(templateDir, file2), "utf8"));
+      if (deck.meta?.componentSet && deck.meta.componentSet !== ext.id && ext.providesTheme) {
+        findings.warnings.push(
+          `template '${id}' names componentSet '${String(deck.meta.componentSet)}', not '${ext.id}' \u2014 it will open in another theme`
+        );
+      }
+      writeFileSync(path4.join(stage, "templates", file2), JSON.stringify(deck, null, 2));
+      templates.push({
+        id,
+        name: deck.meta?.title ?? id,
+        ...deck.meta?.description ? { description: deck.meta.description } : {}
+      });
+    }
+  }
+  for (const meta of metas) {
+    if (!meta.glyph) continue;
+    const from = path4.join(ext.dir, meta.glyph);
+    if (!existsSync4(from)) continue;
+    const name = `${meta.kind.replace(/[^a-z0-9]+/gi, "-")}.svg`;
+    mkdirSync(path4.join(stage, "glyphs"), { recursive: true });
+    writeFileSync(path4.join(stage, "glyphs", name), readFileSync4(from));
+    meta.glyph = `glyphs/${name}`;
+  }
+  for (const extra of ["guide.md", "preview.png"]) {
+    const from = path4.join(ext.dir, extra);
+    if (existsSync4(from)) writeFileSync(path4.join(stage, extra), readFileSync4(from));
+  }
+  const manifest = manifestOf(ext, metas, templates);
+  merge(findings, checkManifest(manifest));
+  if (findings.errors.length > 0) {
+    rmSync(stage, { recursive: true, force: true });
+    return { file: "", bytes: 0, manifest, findings, signed: false };
+  }
+  writeFileSync(path4.join(stage, "manifest.json"), JSON.stringify(manifest, null, 2));
+  const files = packFiles(stage).sort();
+  const digests = {};
+  for (const rel of files) {
+    digests[rel] = createHash("sha256").update(readFileSync4(path4.join(stage, rel))).digest("hex");
+  }
+  if (opts.key) {
+    const key = createPrivateKey(
+      readFileSync4(opts.key.file === "-" ? 0 : opts.key.file, "utf8")
+    );
+    const signature = {
+      algorithm: "ed25519",
+      keyId: opts.key.keyId,
+      signature: signBytes(
+        null,
+        Buffer.from(packFormat.signingPayload(digests), "utf8"),
+        key
+      ).toString("base64")
+    };
+    writeFileSync(path4.join(stage, "signature.json"), JSON.stringify(signature, null, 2));
+    files.push("signature.json");
+  }
+  const zip = new JSZip();
+  for (const rel of files.sort(
+    (a, b) => a === "manifest.json" ? -1 : b === "manifest.json" ? 1 : a.localeCompare(b)
+  )) {
+    zip.file(rel, readFileSync4(path4.join(stage, rel)), {
+      compression: rel.endsWith(".png") ? "STORE" : "DEFLATE",
+      // A fixed date keeps two builds of an unchanged extension
+      // byte-identical.
+      date: /* @__PURE__ */ new Date(0),
+      /*
+       * No implicit directory entries. JSZip stamps those with the current
+       * time whatever `date` says, which is what stopped two builds of an
+       * unchanged extension from being byte-identical — the property the
+       * fixed date above exists to give. Install skips directory entries
+       * anyway (`if (entry.dir) continue`), and so does every unzip.
+       */
+      createFolders: false
+    });
+  }
+  const file = path4.join(outDir, `${ext.id}-${ext.version}.fbkset`);
+  mkdirSync(outDir, { recursive: true });
+  const bytes = await zip.generateAsync({ type: "nodebuffer" });
+  writeFileSync(file, bytes);
+  rmSync(stage, { recursive: true, force: true });
+  return { file, bytes: bytes.length, manifest, findings, signed: Boolean(opts.key) };
+}
+function packFiles(dir, prefix = "") {
+  return readdirSync(dir, { withFileTypes: true }).flatMap((e) => {
+    const rel = prefix ? `${prefix}/${e.name}` : e.name;
+    return e.isDirectory() ? packFiles(path4.join(dir, e.name), rel) : [rel];
+  });
+}
+
+// toolkit/src/publish.ts
+import { copyFileSync, existsSync as existsSync5, mkdirSync as mkdirSync2, readFileSync as readFileSync5, rmSync as rmSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import path5 from "node:path";
+import JSZip2 from "jszip";
+var EXTENSION_KEYWORD = "folienbaukasten-extension";
+function abiKeyword(platformAbi) {
+  return `folienbaukasten-abi-${platformAbi}`;
+}
+function idFromPackageName(packageName) {
+  const scoped = /^@([^/]+)\/(.+)$/.exec(packageName);
+  const base = (scoped ? scoped[2] : packageName).replace(/-extension$/, "");
+  const clean = (s) => s.toLowerCase().replace(/[^a-z0-9-]+/g, "-").replace(/^-+|-+$/g, "");
+  return scoped ? `${clean(scoped[1])}.${clean(base)}` : clean(base);
+}
+function idIsClaimable(packageName, id) {
+  return id === idFromPackageName(packageName) || !id.includes(".");
+}
+async function extractGlyphs(packFile, manifest, dir) {
+  const wanted = /* @__PURE__ */ new Map();
+  for (const c of manifest.components ?? []) if (c.glyph) wanted.set(c.kind, c.glyph);
+  if (wanted.size === 0) return /* @__PURE__ */ new Map();
+  const zip = await JSZip2.loadAsync(readFileSync5(packFile));
+  const written = /* @__PURE__ */ new Map();
+  for (const [kind, rel] of wanted) {
+    const entry = zip.file(rel);
+    if (!entry) continue;
+    const target = path5.join(dir, rel);
+    mkdirSync2(path5.dirname(target), { recursive: true });
+    writeFileSync2(target, await entry.async("nodebuffer"));
+    written.set(kind, rel);
+  }
+  return written;
+}
+async function buildWrapper(opts) {
+  const { manifest, packageName } = opts;
+  const listing = !!opts.purchase;
+  const dir = path5.resolve(opts.outDir);
+  rmSync2(dir, { recursive: true, force: true });
+  mkdirSync2(dir, { recursive: true });
+  const packName = path5.basename(opts.packFile);
+  if (!existsSync5(opts.packFile)) throw new Error(`no pack at ${opts.packFile}`);
+  const glyphs = await extractGlyphs(opts.packFile, manifest, dir);
+  const meta = {
+    id: manifest.id,
+    provides: manifest.provides ?? ["theme"],
+    platformAbi: manifest.platformAbi,
+    // A listing ships no code — that is the half being sold. It still carries
+    // everything needed to *show* the extension, which is what makes a paid
+    // card as informative as a free one.
+    ...listing ? { purchase: opts.purchase } : { pack: packName },
+    ...manifest.swatch ? { swatch: manifest.swatch } : {},
+    ...manifest.components?.length ? {
+      components: manifest.components.map((c) => ({
+        kind: c.kind,
+        ...c.description ? { description: c.description } : {},
+        ...c.webOnly ? { webOnly: true } : {},
+        ...glyphs.has(c.kind) ? { glyph: glyphs.get(c.kind) } : {},
+        ...c.schema ? { schema: c.schema } : {}
+      }))
+    } : {}
+  };
+  const pkg = {
+    name: packageName,
+    version: manifest.version,
+    description: manifest.description ?? `${manifest.name}, a Folienbaukasten extension.`,
+    keywords: [EXTENSION_KEYWORD, abiKeyword(manifest.platformAbi), "folienbaukasten", "slides"],
+    ...manifest.publisher ? { author: manifest.publisher } : {},
+    ...opts.license ? { license: opts.license } : {},
+    ...opts.repository ? { repository: opts.repository } : {},
+    // Not a Node module and never imported: the app reads the tarball, it
+    // does not resolve the package. Saying so stops a bundler from trying.
+    private: false,
+    files: [...listing ? [] : [packName], ...glyphs.size ? ["glyphs"] : [], "README.md"],
+    folienbaukasten: meta,
+    $comment: "A Folienbaukasten extension, delivered through npm. The .fbkset beside this file is the extension; the app downloads this tarball, verifies it against the registry\u2019s own integrity digest, extracts that one file and installs it. Nothing here is imported as a Node module, and no install script runs \u2014 the app never invokes npm."
+  };
+  writeFileSync2(path5.join(dir, "package.json"), `${JSON.stringify(pkg, null, 2)}
+`);
+  const files = ["package.json"];
+  if (!listing) {
+    copyFileSync(opts.packFile, path5.join(dir, packName));
+    files.push(packName);
+  }
+  for (const rel of new Set(glyphs.values())) files.push(rel);
+  writeFileSync2(path5.join(dir, "README.md"), readmeFor(manifest, packageName, opts));
+  files.push("README.md");
+  return { dir, packageName, version: manifest.version, listing, files };
+}
+function readmeFor(manifest, packageName, opts) {
+  const provides = manifest.provides ?? ["theme"];
+  const lines = [
+    `# ${manifest.name}`,
+    "",
+    manifest.description ?? "",
+    "",
+    `A **[Folienbaukasten](https://github.com/harlecin/folienbaukasten)** extension${manifest.publisher ? ` by ${manifest.publisher}` : ""}.`,
+    "",
+    "## What it provides",
+    ""
+  ];
+  if (provides.includes("theme")) {
+    lines.push("- **A theme** \u2014 the colours, type and the header and footer every slide wears.");
+  }
+  for (const c of manifest.components ?? []) {
+    lines.push(
+      `- **${c.kind.split("/").slice(1).join("/")}**${c.webOnly ? " *(web only)*" : ""}${c.description ? ` \u2014 ${c.description}` : ""}`
+    );
+  }
+  if (manifest.templates?.length) {
+    lines.push(`- **${manifest.templates.length} starter deck(s)** to begin from.`);
+  }
+  lines.push(
+    "",
+    "## Installing",
+    "",
+    opts.purchase ? `This is a paid extension. [Buy it](${opts.purchase}), then double-click the \`.fbkset\` you receive \u2014 the app installs it.` : "Open **Extensions \u2192 Browse** in Folienbaukasten and search for it. This package is the delivery vehicle: it carries a prebuilt `.fbkset`, and the app extracts and installs that. It is not a Node module \u2014 do not `npm install` it into a project.",
+    "",
+    "## Compatibility",
+    "",
+    `Built for **platform ABI ${manifest.platformAbi}**${manifest.platformAbi === abi.platformAbi ? "" : " (not this toolkit\u2019s)"}. An app that speaks a different ABI refuses it at install and says so; if that happens, update the app, or ask the publisher for a build that matches.`,
+    "",
+    "---",
+    "",
+    `\`${packageName}\` ${manifest.version}${manifest.publisher ? ` \xB7 ${manifest.publisher}` : ""}`,
+    ""
+  );
+  return lines.join("\n");
+}
+
+// toolkit/bin/fbk-pack.ts
+var argv = process.argv.slice(2);
+var command = argv[0] && !argv[0].startsWith("-") ? argv[0] : "pack";
+var positional = argv.slice(command === argv[0] ? 1 : 0).filter((a) => !a.startsWith("--"));
+var flag = (name) => {
+  const at = argv.indexOf(`--${name}`);
+  return at > 0 ? argv[at + 1] : void 0;
+};
+function targetDir() {
+  const flagged = /* @__PURE__ */ new Set();
+  for (const [i, a] of argv.entries()) if (a.startsWith("--")) flagged.add(argv[i + 1] ?? "");
+  return positional.find((a) => !flagged.has(a)) ?? ".";
+}
+function report(findings) {
+  for (const w of findings.warnings) console.warn(`warning: ${w}`);
+  for (const e of findings.errors) console.error(`error: ${e}`);
+}
+var overrides = {
+  ...flag("id") ? { id: flag("id") } : {},
+  ...flag("name") ? { name: flag("name") } : {},
+  ...flag("version") ? { version: flag("version") } : {},
+  ...flag("publisher") ? { publisher: flag("publisher") } : {}
+};
+switch (command) {
+  case "abi": {
+    console.log(
+      `platform ABI ${abi.platformAbi}, pack format ${abi.packFormatVersion}
+emitted from app ${provenance.app} (${provenance.commit}) on ${provenance.emittedAt}
+${abi.requiredTokens.length} required tokens, ${abi.requiredBoxStyles.length} box styles, ${abi.platformExports.length} platform exports, ${abi.layouts.length} layouts
+layouts: ${abi.layouts.join(", ")}`
+    );
+    break;
+  }
+  case "check": {
+    const { ext, findings } = await checkExtension(targetDir(), overrides);
+    report(findings);
+    if (findings.errors.length > 0) {
+      console.error(`
+${ext.id}: ${findings.errors.length} error(s) \u2014 this pack would not build`);
+      process.exit(1);
+    }
+    console.log(
+      `${ext.id} ${ext.version}: ok \u2014 provides ${ext.provides.join(" + ")}, ${(ext.config.components ?? []).length} component(s), ABI ${abi.platformAbi}${findings.warnings.length ? `, ${findings.warnings.length} warning(s)` : ""}`
+    );
+    break;
+  }
+  case "pack": {
+    const keyFile = flag("key");
+    const keyId = flag("key-id");
+    if (keyFile && !keyId) {
+      console.error("--key needs --key-id (the name this key has in the app)");
+      process.exit(1);
+    }
+    const result = await packExtension(targetDir(), {
+      outDir: flag("out") ?? "dist",
+      overrides,
+      ...keyFile ? { key: { file: keyFile, keyId } } : {}
+    });
+    report(result.findings);
+    if (result.findings.errors.length > 0) {
+      console.error("\nno pack was written.");
+      process.exit(1);
+    }
+    console.log(
+      `${result.file} (${(result.bytes / 1024).toFixed(0)} kB)${result.signed ? ", signed" : ", unsigned"}${result.manifest.templates?.length ? `, ${result.manifest.templates.length} template(s)` : ""}${result.manifest.components?.length ? `, ${result.manifest.components.length} component(s)` : ""}`
+    );
+    break;
+  }
+  /*
+   * Build the pack, then wrap it in a directory `npm publish` understands.
+   *
+   * It stops short of publishing. Sending a package to the registry is
+   * public and effectively irreversible — npm allows unpublish for 72 hours
+   * and never again — so the last step stays a thing a person types.
+   */
+  case "publish": {
+    const packageName = flag("package");
+    if (!packageName) {
+      console.error(
+        "publish needs --package, the npm name to publish under\n  e.g. --package @folienbaukasten/geo-extension"
+      );
+      process.exit(1);
+    }
+    const keyFile = flag("key");
+    const keyId = flag("key-id");
+    if (keyFile && !keyId) {
+      console.error("--key needs --key-id (the name this key has in the app)");
+      process.exit(1);
+    }
+    const outDir = flag("out") ?? "dist/npm";
+    const purchase = flag("purchase");
+    const result = await packExtension(targetDir(), {
+      outDir: path6.join(outDir, ".pack"),
+      overrides,
+      ...keyFile ? { key: { file: keyFile, keyId } } : {}
+    });
+    report(result.findings);
+    if (result.findings.errors.length > 0) {
+      console.error("\nnothing was published \u2014 the pack itself does not build.");
+      process.exit(1);
+    }
+    if (!idIsClaimable(packageName, result.manifest.id)) {
+      console.error(
+        `error: ${packageName} derives the id '${idFromPackageName(packageName)}', but this extension's id is '${result.manifest.id}'.
+Rename the package, or set the id in pack.json to the derived form.`
+      );
+      process.exit(1);
+    }
+    if (!result.manifest.id.includes(".")) {
+      console.warn(
+        `warning: '${result.manifest.id}' is a bare id in a first-come namespace. New extensions should use the '${idFromPackageName(packageName)}' form, where npm prevents collisions. Existing published ids keep theirs \u2014 a deck records the id forever and renaming one breaks it.`
+      );
+    }
+    const wrapper = await buildWrapper({
+      packFile: result.file,
+      manifest: result.manifest,
+      packageName,
+      outDir: path6.join(outDir, "package"),
+      ...purchase ? { purchase } : {},
+      ...flag("license") ? { license: flag("license") } : {},
+      ...flag("repository") ? { repository: flag("repository") } : {}
+    });
+    console.log(
+      `${wrapper.packageName}@${wrapper.version} \u2192 ${wrapper.dir}
+  ${wrapper.files.join(", ")}${wrapper.listing ? "\n  listing only \u2014 no pack, the card will read Buy" : ""}${result.signed ? "\n  the pack is signed" : "\n  the pack is unsigned (installs as \u201Cunverified source\u201D)"}`
+    );
+    console.log(`
+Publish it with:
+  npm publish ${wrapper.dir} --access public`);
+    break;
+  }
+  default:
+    console.error(`unknown command '${command}' \u2014 expected pack, check, publish or abi`);
+    process.exit(1);
+}