@lupinum/ginko 0.0.0-stage → 0.4.0

package/dist/cli/index.mjs

@@ -0,0 +1,679 @@
+#!/usr/bin/env node
+import { existsSync, realpathSync, readFileSync } from 'node:fs';
+import { join, dirname, resolve } from 'node:path';
+import { pathToFileURL, fileURLToPath } from 'node:url';
+import { f as fileLinkIssues } from '../shared/ginko.Dht0xxE5.mjs';
+import { n as coreMessage, i as isTranslatable } from '../shared/ginko.C-QjDn3O.mjs';
+import { s as serializeSchema, a as checkSite, G as validate, g as SITE_BUDGET, A as platformSchema, j as checkSchema } from '../shared/ginko.CrNRBkS5.mjs';
+import { e as defaultsFor, h as fieldsChanged, r as releaseData, m as markdownTrees, g as diffSchema } from '../shared/ginko.C90fPpMP.mjs';
+import { mkdir, writeFile, rm, readdir } from 'node:fs/promises';
+import { execFile } from 'node:child_process';
+import 'comark';
+import 'comark/plugins/alert';
+import 'comark/plugins/attributes';
+import 'comark/plugins/components';
+import 'comark/plugins/emoji';
+import 'comark/plugins/footnotes';
+import 'comark/plugins/frontmatter';
+import 'comark/plugins/math';
+import 'comark/plugins/mermaid';
+import 'comark/plugins/task-list';
+import 'comark/plugins/toc';
+import '@lupinum/ginko-i18n/core';
+import '../shared/ginko.CQvxhyez.mjs';
+
+class CliError extends Error {
+  code;
+  constructor(message, code = "INVALID") {
+    super(message);
+    this.code = code;
+  }
+}
+const isObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+function parseReleaseState(value) {
+  if (!isObject(value)) throw new CliError("The platform did not return a valid state.", "UNAVAILABLE");
+  const { site, schema, schemaRev, contentRev, migrations, entries } = value;
+  const valid = typeof site === "string" && isObject(schema) && isObject(schema.bricks) && Array.isArray(schema.migrations) && isObject(schema.retired) && typeof schemaRev === "number" && typeof contentRev === "number" && Array.isArray(migrations) && Array.isArray(entries) && entries.every((e) => isObject(e) && typeof e.id === "string" && typeof e.brick === "string" && isObject(e.data));
+  if (!valid) throw new CliError("The platform returned an incomplete state.", "UNAVAILABLE");
+  return value;
+}
+function parseExport(value, locator, problem) {
+  const optionalNumber = (v) => v === void 0 || typeof v === "number";
+  const optionalString = (v) => v === void 0 || typeof v === "string";
+  const valid = isObject(value) && value.format === 1 && typeof value.site === "string" && typeof value.name === "string" && typeof value.exportedAt === "string" && isObject(value.schema) && isObject(value.schema.bricks) && typeof value.schemaRev === "number" && typeof value.contentRev === "number" && Array.isArray(value.entries) && value.entries.every((e) => isObject(e) && typeof e.id === "string" && typeof e.brick === "string" && (e.kind === "single" || e.kind === "item") && typeof e.order === "number" && isObject(e.data) && isObject(e.prints) && typeof e.rev === "number" && optionalNumber(e.deletedAt)) && Array.isArray(value.files) && value.files.every((f) => isObject(f) && typeof f.id === "string" && typeof f.name === "string" && typeof f.mime === "string" && typeof f.size === "number" && typeof f[locator] === "string" && optionalNumber(f.width) && optionalNumber(f.height) && optionalString(f.folder) && optionalString(f.sha256) && (f.kept === void 0 || typeof f.kept === "boolean") && (f.focus === void 0 || isObject(f.focus) && typeof f.focus.x === "number" && typeof f.focus.y === "number")) && (value.folders === void 0 || Array.isArray(value.folders) && value.folders.every((f) => isObject(f) && typeof f.id === "string" && typeof f.name === "string" && optionalString(f.parent)));
+  if (!valid) throw new CliError(problem, "UNAVAILABLE" );
+  return value;
+}
+
+async function loadConfig(path, revision = 0) {
+  const url = pathToFileURL(path).href + (revision > 0 ? `?rev=${revision}` : "");
+  let module;
+  try {
+    module = await import(url);
+  } catch (error) {
+    throw new CliError(`ginko.config.ts could not be loaded (${path}): ${error instanceof Error ? error.message : String(error)}`);
+  }
+  const config = isObject(module) ? module.default : void 0;
+  if (!isObject(config) || typeof config.site !== "string" || !isObject(config.bricks)) {
+    throw new CliError(`${path} needs a default export with defineSite(\u2026).`);
+  }
+  return config;
+}
+
+function english(m) {
+  return coreMessage("en", m.key, m.params);
+}
+function explainRejected(rejected) {
+  const lines = ["The schema changes in a way that is not allowed:"];
+  for (const r of rejected) {
+    lines.push(`  \u2717 ${r.path}: ${english(r)}`);
+    const fix = r.fixMsg ? english(r.fixMsg) : r.fix;
+    if (fix) lines.push(`    \u2192 ${fix}`);
+  }
+  return lines;
+}
+function explainProblems(problems) {
+  return ["The release would not be accepted:", ...problems.map((p) => `  \u2717 ${p}`)];
+}
+function explainChanges(changes) {
+  return changes.map((c) => `  + ${english(c)}`);
+}
+function kib(bytes) {
+  return `${Math.ceil(bytes / 1024)} KiB`;
+}
+
+async function checkFileLinks(input) {
+  const schema = serializeSchema(input.config);
+  if (!Object.values(schema.bricks).some((b) => b.source === "files")) return true;
+  let content;
+  try {
+    content = await import('@lupinum/ginko-content');
+  } catch (error) {
+    if (error.code !== "ERR_MODULE_NOT_FOUND") throw error;
+    input.log("Install @lupinum/ginko-content to check file content.");
+    return true;
+  }
+  const contentDir = join(input.root, "content");
+  const publicDir = join(input.root, "public");
+  const result = await content.buildFileBundles({ contentDir, publicDir, schema, drafts: false });
+  let ok = true;
+  for (const e of result.errors) {
+    input.log(content.errorLine(e));
+    ok = false;
+  }
+  const issues = await fileLinkIssues({ bundles: Object.values(result.bundles), schema, site: input.config, publicDir, root: input.root, log: input.log, fetch: input.fetch, external: true });
+  for (const i of issues) {
+    input.log(`content/${i.id}: ${english(i)}`);
+    if (i.severity === "error") ok = false;
+  }
+  return ok;
+}
+
+const BUDGET = SITE_BUDGET;
+const byteSize = (value) => new TextEncoder().encode(JSON.stringify(value ?? null)).byteLength;
+async function buildCandidate(state, site, schema) {
+  const problems = checkSite(site, schema);
+  const applied = new Set([...state.schema.migrations, ...state.migrations].map((m) => m.id));
+  const fresh = schema.migrations.filter((m) => !applied.has(m.id));
+  const writes = /* @__PURE__ */ new Map();
+  const targets = /* @__PURE__ */ new Map();
+  for (const descriptor of fresh) {
+    const target = `${descriptor.brick}.${descriptor.fills}`;
+    const other = targets.get(target);
+    if (other !== void 0) {
+      problems.push(`Migrations \u201C${other}\u201D and \u201C${descriptor.id}\u201D both fill \u201C${target}\u201D. Remove one of them.`);
+      continue;
+    }
+    targets.set(target, descriptor.id);
+    const field = schema.bricks[descriptor.brick]?.fields[descriptor.fills];
+    const migration = Object.hasOwn(site.migrations ?? {}, descriptor.id) ? site.migrations?.[descriptor.id] : void 0;
+    if (!field || !migration) {
+      problems.push(`Migration \u201C${descriptor.id}\u201D has no target field \u201C${target}\u201D.`);
+      continue;
+    }
+    if (field.type === "slug") {
+      problems.push(`Migration \u201C${descriptor.id}\u201D cannot set an address (slug).`);
+      continue;
+    }
+    for (const entry of state.entries) {
+      if (entry.brick !== descriptor.brick) continue;
+      let value;
+      try {
+        value = migrate(migration, descriptor, field, schema, entry.data);
+      } catch (error) {
+        problems.push(`Migration \u201C${descriptor.id}\u201D fails for entry ${entry.id}: ${error instanceof Error ? error.message : String(error)}`);
+        continue;
+      }
+      writes.set(entry.id, { ...writes.get(entry.id), [descriptor.fills]: value });
+    }
+  }
+  const changed = [];
+  const created = [];
+  const checked = [];
+  for (const [key, brick] of Object.entries(schema.bricks)) {
+    if (!Object.hasOwn(state.schema.bricks, key)) {
+      if (brick.kind === "single") created.push({ brick: key, data: defaultsFor(brick.fields) });
+      continue;
+    }
+    const all = fieldsChanged(state.schema, schema, key);
+    for (const entry of state.entries) {
+      if (entry.brick !== key) continue;
+      const next = releaseData(state.schema.bricks[key].fields, brick.fields, entry.data, writes.get(entry.id) ?? {});
+      if (next.roots.length) changed.push({ id: entry.id, brick: key, data: next.data });
+      if (next.roots.length || all) checked.push({ id: entry.id, brick: key, data: next.data });
+    }
+  }
+  for (const entry of checked) {
+    for (const issue of (await validate(schema, entry.brick, entry.data, { mode: "release" })).errors) {
+      problems.push(`Entry ${entry.id} (${entry.brick}), ${issue.path || "entry"}: ${english(issue)}`);
+    }
+  }
+  for (const single of created) {
+    for (const issue of (await validate(schema, single.brick, single.data, { mode: "release" })).errors) {
+      problems.push(`The new single brick \u201C${single.brick}\u201D, ${issue.path || "entry"}: ${english(issue)}`);
+    }
+  }
+  const changedData = new Map(changed.map((c) => [c.id, c.data]));
+  const bytes = { site: 0, largest: 0 };
+  const count = (size, label) => {
+    bytes.site += size;
+    bytes.largest = Math.max(bytes.largest, size);
+    if (size > BUDGET.entryBytes) problems.push(`${label} is too large (at most 256 KiB).`);
+  };
+  const sizeOf = async (brick, data) => {
+    const fields = (schema.bricks[brick] ?? state.schema.bricks[brick])?.fields ?? {};
+    return byteSize(data) + byteSize(await markdownTrees(fields, data));
+  };
+  for (const entry of state.entries) count(await sizeOf(entry.brick, changedData.get(entry.id) ?? entry.data), `Entry ${entry.id} (${entry.brick})`);
+  for (const single of created) count(await sizeOf(single.brick, single.data), `The new single brick \u201C${single.brick}\u201D`);
+  if (bytes.site > BUDGET.siteBytes) problems.push("The site has reached its storage budget (4 MiB).");
+  const liveEntries = state.entries.filter((entry) => entry.deletedAt === null).length;
+  if (liveEntries + created.length > BUDGET.entries) problems.push(`The site has reached its limit of ${BUDGET.entries} entries.`);
+  return {
+    schema,
+    writes: [...writes].map(([entry, fields]) => ({ entry, fields })),
+    changed,
+    created,
+    problems,
+    bytes
+  };
+}
+function migrate(migration, descriptor, field, schema, data) {
+  const mainLocale = schema.locales[0];
+  const fields = schema.bricks[descriptor.brick].fields;
+  if (!isTranslatable(field)) {
+    return migration.compute(structuredClone(data), { locales: schema.locales, mainLocale }) ?? null;
+  }
+  const out = {};
+  for (const locale of schema.locales) {
+    const value = migration.compute(forLocale(fields, data, locale), { locales: schema.locales, mainLocale, locale });
+    if (value !== void 0 && value !== null) out[locale] = value;
+  }
+  return out;
+}
+function forLocale(fields, data, locale) {
+  const out = {};
+  for (const [name, value] of Object.entries(data)) {
+    const field = Object.hasOwn(fields, name) ? fields[name] : void 0;
+    if (field && isTranslatable(field)) {
+      const picked = isObject(value) ? value[locale] : void 0;
+      if (picked !== void 0) out[name] = picked;
+    } else if (field?.type === "list" && Array.isArray(value)) {
+      out[name] = value.map((row) => isObject(row) ? forLocale(field.of, row, locale) : row);
+    } else {
+      out[name] = value;
+    }
+  }
+  return out;
+}
+
+async function plan(state, site) {
+  const schema = platformSchema(serializeSchema(site));
+  if (checkSchema(schema).length > 0) return { schema, changes: [], rejected: [], candidate: await buildCandidate(state, site, schema) };
+  const known = /* @__PURE__ */ new Map();
+  for (const m of [...state.schema.migrations, ...state.migrations]) {
+    known.set(m.id, { id: m.id, brick: m.brick, fills: m.fills, fingerprint: m.fingerprint });
+  }
+  const { changes, rejected } = diffSchema({ ...state.schema, migrations: [...known.values()] }, schema);
+  if (rejected.length > 0) return { schema, changes, rejected, candidate: null };
+  return { schema, changes, rejected, candidate: await buildCandidate(state, site, schema) };
+}
+
+async function check(input) {
+  const problems = checkSite(input.config);
+  if (problems.length > 0) {
+    input.log("ginko.config.ts is invalid:");
+    for (const problem of problems) input.log(`  \u2717 ${problem}`);
+    return false;
+  }
+  const image = checkSeoImage(input.config, input.root, input.log);
+  const links = await checkFileLinks({ config: input.config, root: input.root, log: input.log, fetch: input.fetch }) && image;
+  if (!input.connect) {
+    if (links) input.log("OK: schema and links are fine.");
+    return links;
+  }
+  try {
+    return await checkRelease({ config: input.config, platform: input.connect(), log: input.log }) && links;
+  } catch (error) {
+    if (links) throw error;
+    input.log(`Skipped the comparison with production: ${error instanceof Error ? error.message : String(error)}`);
+    return false;
+  }
+}
+function checkSeoImage(config, root, log) {
+  const image = config.seo?.image;
+  if (!image || !image.startsWith("/") || image.startsWith("//")) return true;
+  const file = image.split(/[?#]/)[0];
+  if (existsSync(join(root, "public", file))) return true;
+  log(`ginko.config.ts: seo.image "${image}" is missing. Fix: add the file public${file}, or change seo.image.`);
+  return false;
+}
+async function checkRelease(input) {
+  const state = await input.platform.state(input.config.site);
+  if (state.site !== input.config.site) throw new CliError(`The key belongs to the site \u201C${state.site}\u201D, not to \u201C${input.config.site}\u201D.`, "FORBIDDEN");
+  const result = await plan(state, input.config);
+  input.log(`Site \u201C${state.site}\u201D: schema version ${state.schemaRev}, content ${state.contentRev}.`);
+  if (result.rejected.length > 0) {
+    for (const line of explainRejected(result.rejected)) input.log(line);
+    return false;
+  }
+  if (result.changes.length > 0) {
+    input.log("Allowed changes:");
+    for (const line of explainChanges(result.changes)) input.log(line);
+  } else {
+    input.log("No schema changes.");
+  }
+  const candidate = result.candidate;
+  const migrations = result.schema.migrations.filter((m) => !state.migrations.some((s) => s.id === m.id) && !state.schema.migrations.some((s) => s.id === m.id));
+  if (migrations.length > 0) input.log(`New migrations: ${migrations.map((m) => m.id).join(", ")}. Writes: ${candidate.writes.length} entries.`);
+  input.log(`Size: site ${kib(candidate.bytes.site)} of 4 MiB, largest entry ${kib(candidate.bytes.largest)} (limit 256 KiB).`);
+  if (candidate.problems.length > 0) {
+    for (const line of explainProblems(candidate.problems)) input.log(line);
+    return false;
+  }
+  input.log("OK: A release with this schema would be accepted.");
+  return true;
+}
+
+class PlatformError extends Error {
+  code;
+  status;
+  details;
+  constructor(code, message, status, details) {
+    super(message);
+    this.code = code;
+    this.status = status;
+    this.details = details;
+  }
+}
+const PUSH_KEY_FORMAT = /^ginko_([a-z][a-z0-9-]{1,40})_[a-z0-9]{32}$/;
+const READ_TIMEOUT_MS = 3e4;
+const WRITE_TIMEOUT_MS = 6e4;
+const UNKNOWN_OUTCOME = "It is unknown whether the release arrived. The same commit can run again without risk.";
+function checkPlatformUrl(url) {
+  let parsed;
+  try {
+    parsed = new URL(url);
+  } catch {
+    throw new CliError("GINKO_PLATFORM is not a valid URL.", "USAGE");
+  }
+  const local = ["localhost", "127.0.0.1", "[::1]"].includes(parsed.hostname);
+  if (parsed.protocol !== "https:" && !(parsed.protocol === "http:" && local)) {
+    throw new CliError("GINKO_PLATFORM must start with https:// (http:// only for localhost, 127.0.0.1 and [::1]).", "USAGE");
+  }
+}
+function createPlatform(options) {
+  checkPlatformUrl(options.url);
+  const key = options.key.trim();
+  if (!PUSH_KEY_FORMAT.test(key)) throw new CliError("GINKO_KEY is not a valid push key (expected: ginko_<site>_<32 characters a-z0-9>).", "USAGE");
+  const base = options.url.replace(/\/+$/, "");
+  async function call(path, init = {}, deadlineMs = READ_TIMEOUT_MS, note = "") {
+    const signal = AbortSignal.timeout(deadlineMs);
+    const after = note ? ` ${note}` : "";
+    let response;
+    try {
+      response = await options.fetch(`${base}${path}`, {
+        ...init,
+        headers: { authorization: `Bearer ${key}`, ...init.body ? { "content-type": "application/json" } : {} },
+        // A redirect would re-send the key or the release body to another address.
+        redirect: "manual",
+        signal
+      });
+    } catch {
+      throw new CliError(signal.aborted ? timeoutMessage(deadlineMs, note) : "The platform is not reachable. Check GINKO_PLATFORM and your network.", "UNAVAILABLE");
+    }
+    if (response.type === "opaqueredirect" || response.status >= 300 && response.status < 400) {
+      throw new CliError("The platform redirects; check GINKO_PLATFORM.", "USAGE");
+    }
+    let text;
+    try {
+      text = await response.text();
+    } catch {
+      throw new CliError(signal.aborted ? timeoutMessage(deadlineMs, note) : `The connection to the platform broke while reading the response.${after}`, "UNAVAILABLE");
+    }
+    let body;
+    try {
+      body = JSON.parse(text);
+    } catch {
+      body = void 0;
+    }
+    if (!response.ok) {
+      const error = isObject(body) ? body : {};
+      if (response.status === 404 && typeof error.code !== "string") {
+        throw new CliError("No Ginko platform answers at this address (HTTP 404); check GINKO_PLATFORM.", "USAGE");
+      }
+      throw new PlatformError(
+        typeof error.code === "string" ? error.code : `HTTP_${response.status}`,
+        typeof error.message === "string" ? error.message.replaceAll(key, "\u2026") : `The platform responded with HTTP ${response.status}.`,
+        response.status,
+        error.details
+      );
+    }
+    return body;
+  }
+  function timeoutMessage(deadlineMs, note) {
+    return `The platform did not respond within ${deadlineMs / 1e3} s.${note ? ` ${note}` : ""}`;
+  }
+  return {
+    async state(site) {
+      return parseReleaseState(await call(`/release/state?site=${encodeURIComponent(site)}`));
+    },
+    async release(body) {
+      const answer = await call("/release", { method: "POST", body: JSON.stringify(body) }, WRITE_TIMEOUT_MS, UNKNOWN_OUTCOME);
+      if (!isObject(answer) || typeof answer.schemaRev !== "number" || typeof answer.contentRev !== "number") {
+        throw new CliError(`The platform did not send a valid response to the release. ${UNKNOWN_OUTCOME}`, "UNAVAILABLE");
+      }
+      return { schemaRev: answer.schemaRev, contentRev: answer.contentRev };
+    },
+    async exportSite(site) {
+      return parseExport(await call(`/export?site=${encodeURIComponent(site)}`), "url", "The platform did not return a valid export.");
+    }
+  };
+}
+
+const EXTENSIONS = {
+  "image/jpeg": ".jpg",
+  "image/png": ".png",
+  "image/webp": ".webp",
+  "image/avif": ".avif",
+  "application/pdf": ".pdf"
+};
+function siteOfKey(key) {
+  const match = PUSH_KEY_FORMAT.exec(key.trim());
+  if (!match) throw new CliError("GINKO_KEY is not a valid key.", "USAGE");
+  return match[1];
+}
+function defaultDir(site, now) {
+  return `ginko-export-${site}-${now.toISOString().slice(0, 10)}`;
+}
+function pathOf(file) {
+  return `files/${file.id}${EXTENSIONS[file.mime] ?? ""}`;
+}
+async function requireEmpty(dir) {
+  let names;
+  try {
+    names = await readdir(dir);
+  } catch (error) {
+    const code = error.code;
+    if (code === "ENOENT") return;
+    if (code === "ENOTDIR") throw new CliError(`\u201C${dir}\u201D is not a folder.`, "USAGE");
+    throw error;
+  }
+  if (names.length > 0) throw new CliError(`The folder \u201C${dir}\u201D is not empty. Choose a new folder.`, "USAGE");
+}
+async function exportSite(input) {
+  const { dir } = input;
+  await requireEmpty(dir);
+  const answer = await input.platform.exportSite(input.site);
+  await mkdir(join(dir, "files"), { recursive: true });
+  try {
+    const files = [];
+    for (const file of answer.files) {
+      const { url, ...info } = file;
+      const path = pathOf(file);
+      let bytes;
+      try {
+        const response = await input.fetch(url);
+        if (!response.ok) throw new CliError(`The file \u201C${file.name}\u201D could not be downloaded (HTTP ${response.status}).`, "UNAVAILABLE");
+        bytes = new Uint8Array(await response.arrayBuffer());
+      } catch (error) {
+        if (error instanceof CliError) throw error;
+        throw new CliError(`The file \u201C${file.name}\u201D could not be downloaded.`, "UNAVAILABLE");
+      }
+      if (bytes.byteLength !== file.size) {
+        throw new CliError(`The file \u201C${file.name}\u201D is incomplete: ${bytes.byteLength} instead of ${file.size} bytes.`, "UNAVAILABLE");
+      }
+      await writeFile(join(dir, path), bytes);
+      files.push({ ...info, path });
+      input.log(`File ${files.length}/${answer.files.length}: ${path}`);
+    }
+    const out = { ...answer, files };
+    await writeFile(join(dir, "export.json"), `${JSON.stringify(out, null, 2)}
+`);
+  } catch (error) {
+    await rm(dir, { recursive: true, force: true });
+    throw error;
+  }
+  return { dir, entries: answer.entries.length, files: answer.files.length };
+}
+
+const RETRY_WAITS_MS = [2e3, 4e3, 8e3, 16e3, 32e3];
+async function release(input) {
+  const site = input.config.site;
+  for (let attempt = 0; ; attempt++) {
+    if (attempt > 0 && await input.branchHead() !== input.commit) return { deploy: false, reason: "superseded" };
+    const state = await input.platform.state(site);
+    if (state.site !== site) throw new CliError(`The key belongs to the site \u201C${state.site}\u201D, not to \u201C${site}\u201D.`, "FORBIDDEN");
+    const result = await plan(state, input.config);
+    if (result.rejected.length > 0) throw new CliError(explainRejected(result.rejected).join("\n"));
+    if (!result.candidate) throw new Error("Internal error: candidate is missing.");
+    if (result.candidate.problems.length > 0) throw new CliError(explainProblems(result.candidate.problems).join("\n"));
+    try {
+      const answer = await input.platform.release({
+        site,
+        commit: input.commit,
+        expectedSchemaRev: state.schemaRev,
+        expectedContentRev: state.contentRev,
+        schema: result.candidate.schema,
+        writes: result.candidate.writes
+      });
+      return { deploy: true, ...answer };
+    } catch (error) {
+      if (error instanceof PlatformError && error.code === "CHANGED_SINCE" && attempt < RETRY_WAITS_MS.length) {
+        const wait = RETRY_WAITS_MS[attempt];
+        input.log(`The site changed during the release. Retrying in ${wait / 1e3} s.`);
+        await input.sleep(wait);
+        continue;
+      }
+      throw error;
+    }
+  }
+}
+
+function realDeps() {
+  return {
+    env: process.env,
+    git: (args) => new Promise((done, fail) => {
+      execFile("git", args, (error, stdout) => error ? fail(error) : done(stdout));
+    }),
+    stdout: (text) => {
+      process.stdout.write(text);
+    },
+    log: (line) => {
+      process.stderr.write(`${line}
+`);
+    },
+    fetch: (input, init) => fetch(input, init)
+  };
+}
+function codeOf(error) {
+  return error instanceof CliError || error instanceof PlatformError ? error.code : "UNEXPECTED";
+}
+function exitCodeOf(error) {
+  const code = codeOf(error);
+  if (code === "UNAUTHORIZED" || code === "FORBIDDEN") return 4;
+  if (code === "USAGE") return 2;
+  if (code === "UNAVAILABLE" || code === "CHANGED_SINCE") return 3;
+  if (error instanceof PlatformError) {
+    if (error.status === 401 || error.status === 403) return 4;
+    if (error.status >= 500 || error.status === 408 || error.status === 429) return 3;
+  }
+  return 1;
+}
+async function runCommand(deps, command) {
+  try {
+    const fields = await command();
+    deps.stdout(`${JSON.stringify({ ok: true, ...fields })}
+`);
+    return 0;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    const code = codeOf(error);
+    deps.log(error instanceof PlatformError ? `Error ${code}: ${message}` : message);
+    deps.stdout(`${JSON.stringify({ ok: false, error: { code, message } })}
+`);
+    return exitCodeOf(error);
+  }
+}
+function parseArgs(argv) {
+  const args = { flags: /* @__PURE__ */ new Set() };
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === "--config" || arg.startsWith("--config=")) {
+      const value = arg === "--config" ? argv[++i] : arg.slice("--config=".length);
+      if (!value) throw new CliError("--config needs a path.", "USAGE");
+      args.config = value;
+    } else if (arg.startsWith("-")) args.flags.add(arg);
+    else if (args.command === void 0) args.command = arg;
+    else if (args.folder === void 0) args.folder = arg;
+    else throw new CliError(`Unexpected argument \u201C${arg}\u201D.`, "USAGE");
+  }
+  return args;
+}
+async function runCli(argv, deps, cli) {
+  if (argv.includes("--help") || argv.includes("-h")) {
+    deps.stdout(cli.usage);
+    return 0;
+  }
+  if (cli.version && argv.includes("--version")) {
+    deps.stdout(`${cli.version()}
+`);
+    return 0;
+  }
+  return runCommand(deps, async () => {
+    const args = parseArgs(argv);
+    if (args.command === void 0) throw new CliError("No command given. Run it with --help to see the commands.", "USAGE");
+    const command = Object.hasOwn(cli.commands, args.command) ? cli.commands[args.command] : void 0;
+    if (!command) throw new CliError(`Unknown command \u201C${args.command}\u201D. Run it with --help to see the commands.`, "USAGE");
+    const name = `${cli.prefix}${args.command}`;
+    const flag = [...args.flags].find((f) => f !== "--json" && !command.flags?.includes(f));
+    if (flag) throw new CliError(`Unknown option \u201C${flag}\u201D for ${name}.`, "USAGE");
+    if (args.folder !== void 0 && !command.folder) throw new CliError(`Unexpected argument \u201C${args.folder}\u201D for ${name}.`, "USAGE");
+    if (args.folder === void 0 && command.folder === "required") throw new CliError(`${name} needs a folder: ${name} <folder>.`, "USAGE");
+    return command.run(args);
+  });
+}
+function env(deps, ...names) {
+  const value = names.map((name) => deps.env[name]).find(Boolean);
+  if (!value) throw new CliError(`The environment variable ${names[0]} is missing.`, "USAGE");
+  return value;
+}
+const PLATFORM_ENV = ["GINKO_PLATFORM", "NUXT_PUBLIC_GINKO_PLATFORM"];
+function connectPlatform(deps) {
+  return createPlatform({ url: env(deps, ...PLATFORM_ENV), key: env(deps, "GINKO_KEY"), fetch: deps.fetch });
+}
+function isEntryPoint(url) {
+  return process.argv[1] !== void 0 && realpathSync(process.argv[1]) === fileURLToPath(url);
+}
+
+const USAGE = `Usage: ginko <command> [--config <file>]
+
+Commands:
+  check [--offline]  Check ginko.config.ts and the links in content/, and for platform bricks the schema against
+                     production. Writes nothing. Platform bricks need GINKO_PLATFORM and GINKO_KEY, unless --offline
+                     skips the comparison with production.
+  release            Deploy the schema and content to production (CI). Needs GINKO_PLATFORM, GINKO_KEY and
+                     GINKO_COMMIT (or GITHUB_SHA). Deploy the site only when it prints "deploy":true.
+  export [folder]    Save the schema, entries and files from production to a new or empty folder
+                     (default: ginko-export-<site>-<yyyy-mm-dd>). Needs GINKO_PLATFORM and GINKO_KEY.
+
+Options:
+  --config <file>    Path to ginko.config.ts (default: ./ginko.config.ts)
+  -h, --help         Show this help
+  --version          Show the version
+
+Every run prints one JSON line on stdout. Exit codes: 0 ok, 1 invalid or rejected, 2 usage,
+3 platform unavailable (run again), 4 key not allowed.
+`;
+function version() {
+  return JSON.parse(readFileSync(new URL("../../package.json", import.meta.url), "utf8")).version;
+}
+const COMMIT_ENV = ["GINKO_COMMIT", "GITHUB_SHA"];
+async function branchHead(deps) {
+  const remote = deps.env.GINKO_REMOTE || "origin";
+  const branch = deps.env.GINKO_BRANCH || "main";
+  let stdout;
+  try {
+    stdout = await deps.git(["ls-remote", remote, `refs/heads/${branch}`]);
+  } catch {
+    throw new CliError(`Could not read ${remote}/${branch} (git ls-remote ${remote} refs/heads/${branch}).`, "UNAVAILABLE");
+  }
+  const sha = stdout.trim().split(/\s+/)[0];
+  if (!sha) throw new CliError(`The branch ${branch} does not exist on ${remote}. Set GINKO_BRANCH and GINKO_REMOTE.`, "USAGE");
+  return sha;
+}
+const sleep = (ms) => new Promise((done) => setTimeout(done, ms));
+function main(argv, deps = realDeps()) {
+  const configPathOf = (args) => resolve(args.config ?? "ginko.config.ts");
+  return runCli(argv, deps, {
+    prefix: "ginko ",
+    usage: USAGE,
+    version,
+    commands: {
+      check: {
+        flags: ["--offline"],
+        async run(args) {
+          const configPath = configPathOf(args);
+          const config = await loadConfig(configPath);
+          const offline = args.flags.has("--offline");
+          const platformBricks = Object.values(config.bricks).some((b) => b.source !== "files");
+          const compared = platformBricks && !offline;
+          const ok = await check({
+            config,
+            connect: compared ? () => connectPlatform(deps) : void 0,
+            root: dirname(configPath),
+            fetch: deps.fetch,
+            log: deps.log
+          });
+          if (platformBricks && offline) deps.log("Skipped the comparison with production (--offline).");
+          if (!ok) throw new CliError("ginko check found problems. Each one is listed on stderr.");
+          return { compared };
+        }
+      },
+      release: {
+        async run(args) {
+          const commit = env(deps, ...COMMIT_ENV);
+          if (await branchHead(deps) !== commit) return { deploy: false, reason: "superseded" };
+          const config = await loadConfig(configPathOf(args));
+          return release({ config, commit, platform: connectPlatform(deps), branchHead: () => branchHead(deps), sleep, log: deps.log });
+        }
+      },
+      // Works on the hosted content only, so it needs no config.
+      export: {
+        folder: "optional",
+        async run(args) {
+          const platform = connectPlatform(deps);
+          const site = siteOfKey(env(deps, "GINKO_KEY"));
+          return exportSite({ platform, site, dir: args.folder ?? defaultDir(site, /* @__PURE__ */ new Date()), fetch: deps.fetch, log: deps.log });
+        }
+      }
+    }
+  });
+}
+if (isEntryPoint(import.meta.url)) {
+  void main(process.argv.slice(2)).then((code) => {
+    process.exitCode = code;
+  });
+}
+
+export { main };

package/dist/index.d.mts

@@ -0,0 +1,6 @@
+export { L as LinkConfig, M as Migration, b as MigrationContext, R as Redirect, c as RouteTemplate, S as SiteInput, e as collection, f as defineSite, s as single } from './shared/ginko.akHewCGt.mjs';
+export { B as Brick, d as BrickSource, k as ChoiceOption, e as CollectionBrick, m as ComponentDef, a as ComponentRegistry, C as Currency, q as DataOf, t as Field, F as Fields, v as FileValue, y as ImageValue, z as ItemOf, J as Json, c as Label, L as Locale, Q as MarkdownProfile, U as MarkdownToc, M as MarkdownTree, X as MarkdownValue, Z as Money, f as SingleBrick, T as Task, a8 as TocLink, ab as UnknownChoice, V as Visibility, W as WeekInfo, aj as defineComponents, ao as f, au as plainText, ax as startOfWeek } from './shared/ginko.D-fNojn9.mjs';
+export { C as Condition, N as NavNode, Q as Query, d as SeoImage, j as formatMoney, s as safeHref } from './shared/ginko.BTUfZCfa.mjs';
+import './shared/ginko.Bwan3BB-.mjs';
+import '@lupinum/ginko-i18n/core';
+import 'comark';