@kromatv/sdk 0.1.40-canary.0

package/dist/cli.js

@@ -0,0 +1,2523 @@
+#!/usr/bin/env bun
+// @bun
+var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+
+// ../registry/src/documents/v1.ts
+import { z } from "zod";
+var Integrity, PointDef, Contribution, PointReq, RegistryArtifact, DependencyMap, RegistryVersion, ModuleMeta, RegistryEntry, RegistryIndex, ModuleRecord, RegistryDescriptor;
+var init_v1 = __esm(() => {
+  Integrity = z.string().regex(/^sha256-[A-Za-z0-9+/]{43}=$/, "not an sha256 SRI");
+  PointDef = z.object({
+    name: z.string(),
+    version: z.number().int().positive().nullish(),
+    methods: z.array(z.string()).nullish()
+  }).catchall(z.json());
+  Contribution = z.object({
+    point: z.string(),
+    version: z.number().int().positive().nullish(),
+    id: z.string().nullish()
+  }).catchall(z.json());
+  PointReq = z.object({
+    point: z.string(),
+    version: z.string().nullish(),
+    id: z.string().nullish(),
+    optional: z.boolean().nullish()
+  }).catchall(z.json());
+  RegistryArtifact = z.object({
+    target: z.string().nullish(),
+    url: z.string(),
+    size: z.number().int().nonnegative(),
+    integrity: Integrity,
+    contentHash: Integrity.nullish()
+  });
+  DependencyMap = z.record(z.string(), z.string());
+  RegistryVersion = z.object({
+    schemaVersion: z.number().int().nullish(),
+    engines: z.record(z.string(), z.string()).nullish(),
+    library: z.boolean().nullish(),
+    dependencies: DependencyMap.nullish(),
+    optionalDependencies: DependencyMap.nullish(),
+    definesPoints: z.array(PointDef).nullish(),
+    contributes: z.array(Contribution).nullish(),
+    consumes: z.array(PointReq).nullish(),
+    artifacts: z.array(RegistryArtifact)
+  });
+  ModuleMeta = z.object({
+    id: z.string(),
+    name: z.string(),
+    description: z.string().nullish(),
+    author: z.string().nullish(),
+    homepage: z.string().nullish(),
+    license: z.string().nullish(),
+    keywords: z.array(z.string()).nullish(),
+    tags: z.array(z.string()).nullish(),
+    icon: z.string().nullish()
+  });
+  RegistryEntry = ModuleMeta.extend(RegistryVersion.shape).extend({
+    version: z.string()
+  });
+  RegistryIndex = z.array(RegistryEntry);
+  ModuleRecord = ModuleMeta.extend({
+    apiVersion: z.number().int().min(1),
+    latest: z.string(),
+    distTags: z.record(z.string(), z.string()).default({}),
+    versions: z.record(z.string(), RegistryVersion)
+  });
+  RegistryDescriptor = z.object({
+    apiVersion: z.number().int().min(1),
+    name: z.string(),
+    url: z.string(),
+    modules: z.array(z.string())
+  });
+});
+
+// ../registry/src/documents/index.ts
+var REGISTRY_API_VERSION = 1, DOCUMENT_SCHEMAS;
+var init_documents = __esm(() => {
+  init_v1();
+  init_v1();
+  DOCUMENT_SCHEMAS = {
+    1: { registry: RegistryDescriptor, index: RegistryIndex, module: ModuleRecord }
+  };
+});
+
+// ../registry/src/manifest/v2.ts
+import { z as z2 } from "zod";
+function speaksCurrentSchema(manifest) {
+  return manifest.schemaVersion === SCHEMA_VERSION;
+}
+function dependenciesOf(manifest) {
+  return mapOf(manifest.dependencies);
+}
+function optionalDependenciesOf(manifest) {
+  return mapOf(manifest.optionalDependencies);
+}
+var DependencyMap2, ConfigField, SCHEMA_VERSION = 2, REVERSE_DNS_ID, TableOrColumn, CoreScope, Storage, Manifest, mapOf = (raw) => raw ?? {}, ArtifactRef, DescribedModule;
+var init_v2 = __esm(() => {
+  init_v1();
+  DependencyMap2 = z2.record(z2.string(), z2.string()).nullish();
+  ConfigField = z2.object({
+    key: z2.string(),
+    label: z2.string(),
+    type: z2.enum(["string", "bool", "number", "select"]),
+    default: z2.string().nullish(),
+    options: z2.array(z2.string()).nullish(),
+    placeholder: z2.string().nullish(),
+    secret: z2.boolean().nullish(),
+    required: z2.boolean().nullish()
+  });
+  REVERSE_DNS_ID = /^[a-z0-9]+(?:\.[a-z0-9-]+)+$/;
+  TableOrColumn = z2.string().regex(/^[A-Za-z_]\w*(?:\.[A-Za-z_]\w*)?$/);
+  CoreScope = z2.object({
+    read: z2.array(TableOrColumn).nullish().describe('Tables and columns this module may SELECT, as "table" or "table.column". A column named in a WHERE is reached as much as one that is projected.'),
+    write: z2.array(TableOrColumn).nullish().describe("Tables this module may INSERT / UPDATE / DELETE. A write grant is not a read grant, and a foreign key drags its other table in: writing a child reads the parent, and a cascading delete writes the child.")
+  });
+  Storage = z2.object({
+    core: CoreScope.nullish().describe("The slice of the shared core database this module may reach. Enforced per connection by SQLite's authorizer at prepare time, so it cannot be worked around by building the SQL as a string. Absent means none of it."),
+    adopt: z2.array(z2.string().regex(/^[A-Za-z_]\w*$/)).nullish().describe("Tables this module used to keep in the core database and now owns. The core moves each one - schema, indexes and rows - into the module's own file before the module is spawned, then drops the core copy, so it happens exactly once.")
+  });
+  Manifest = z2.object({
+    $schema: z2.string().optional().describe("The schema this manifest is written against, so an editor can offer completion and inline docs. Ignored everywhere else."),
+    schemaVersion: z2.number().int().nullish().describe("The manifest schema this module is built against. A server that speaks a different one refuses the bundle rather than reading it on a best-effort basis, because the fields that moved between versions parse as absent, not as errors."),
+    id: z2.string().describe("Reverse-DNS identifier, e.g. tv.kroma.torrents. The runtime join key."),
+    name: z2.string().describe("Display name, shown in the Store and the admin."),
+    version: z2.string().describe("The module's own semver version. Bump it whenever the bundle changes: CI content-hashes each bundle and refuses a run whose bytes moved while this stood still."),
+    description: z2.string().nullish().describe("One line, shown on the Store card."),
+    engines: z2.record(z2.string(), z2.string()).nullish().describe('What this module needs from its host, by engine name and semver range, e.g. { "server": ">=0.1.4" }. A bare version means "at least that". An engine the host cannot check is refused, not ignored.'),
+    library: z2.boolean().nullish().describe("A library module: its .kmod ships no native binary (its code is co-linked into the processes that need it), so the supervisor registers it but spawns no process."),
+    dependencies: DependencyMap2.describe('Hard dependencies as a map of module id to semver range; a bare "*" means any version. Enforced on the backend.'),
+    optionalDependencies: DependencyMap2.describe("Soft dependencies, same shape: version-checked and ordered first when present, but not required."),
+    definesPoints: z2.array(PointDef).nullish().describe("Points this module INVENTS, for other modules to plug into. `name` is local; the full name is `<this module's id>/<name>`, so ownership reads off the name and two authors cannot collide."),
+    contributes: z2.array(Contribution).nullish().describe("Points this module answers, its own included. One declaration where there used to be three: `provides` described a capability for the admin picker and `ports` described the RPC name resolution matched on, and an engine advertised the same fact under both."),
+    consumes: z2.array(PointReq).nullish().describe('Points this module CALLS. Unlike a module id in `dependencies`, this says "something has to answer this", which is what a store can resolve without naming a peer.'),
+    config: z2.array(ConfigField).nullish().describe("Admin-configurable settings this module exposes, rendered as a form."),
+    storage: Storage.nullish().describe("This module's databases, and the capability itself: without a storage object the module gets no database and its binary does not link SQLite. Its presence alone grants it its own file at <data>/modules/<id>/module.sqlite, where its migrations run and which it owns outright."),
+    feRemote: z2.object({ module: z2.string() }).nullish().describe("Frontend Module Federation remote (runtime-loaded modules). The entry URL is derived by the server as /modules/<id>/remoteEntry.js."),
+    author: z2.string().nullish().describe("Who published it, shown on the Store page."),
+    homepage: z2.string().nullish().describe("Where to read more about it."),
+    license: z2.string().nullish().describe("SPDX identifier, e.g. GPL-2.0-or-later."),
+    keywords: z2.array(z2.string()).nullish().describe("Free-form search terms, matched by the Store's search."),
+    tags: z2.array(z2.string()).nullish().describe("Words a store filters by. Defaults to the local half of each point this module answers, so it rarely needs writing by hand.")
+  });
+  ArtifactRef = z2.object({
+    target: z2.string().nullish(),
+    url: z2.string(),
+    size: z2.number().int().nonnegative(),
+    sha256: z2.string().nullish(),
+    contentHash: z2.string().nullish()
+  });
+  DescribedModule = Manifest.extend({
+    icon: z2.string().nullish(),
+    artifacts: z2.array(ArtifactRef)
+  });
+});
+
+// ../registry/src/manifest/index.ts
+var MODULE_SCHEMA_VERSION = 2, MANIFEST_SCHEMAS;
+var init_manifest = __esm(() => {
+  init_v2();
+  init_v2();
+  MANIFEST_SCHEMAS = { 2: Manifest };
+});
+
+// ../registry/src/semver.ts
+function parse(raw) {
+  const m = SEMVER.exec(raw.trim());
+  if (!m)
+    return null;
+  const [, major, minor, patch, pre] = m;
+  return {
+    major: Number(major),
+    minor: Number(minor),
+    patch: Number(patch),
+    prerelease: pre ? pre.split(".").map((p) => /^\d+$/.test(p) ? Number(p) : p) : []
+  };
+}
+function sign(a, b) {
+  if (a < b)
+    return -1;
+  return a > b ? 1 : 0;
+}
+function comparePart(a, b) {
+  const aNum = typeof a === "number";
+  const bNum = typeof b === "number";
+  if (aNum && bNum)
+    return sign(a, b);
+  if (aNum !== bNum)
+    return aNum ? -1 : 1;
+  return sign(String(a), String(b));
+}
+function comparePrerelease(a, b) {
+  if (a.length === 0 || b.length === 0) {
+    if (a.length === b.length)
+      return 0;
+    return a.length === 0 ? 1 : -1;
+  }
+  const len = Math.max(a.length, b.length);
+  for (let i = 0;i < len; i++) {
+    const x = a[i];
+    const y = b[i];
+    if (x === undefined)
+      return -1;
+    if (y === undefined)
+      return 1;
+    const c = comparePart(x, y);
+    if (c !== 0)
+      return c;
+  }
+  return 0;
+}
+function compare(a, b) {
+  for (const k of ["major", "minor", "patch"]) {
+    if (a[k] !== b[k])
+      return a[k] < b[k] ? -1 : 1;
+  }
+  return comparePrerelease(a.prerelease, b.prerelease);
+}
+function compareRaw(a, b) {
+  const [x, y] = [parse(a), parse(b)];
+  if (!x || !y) {
+    if (x)
+      return 1;
+    if (y)
+      return -1;
+    return 0;
+  }
+  return compare(x, y);
+}
+function channelOf(version) {
+  const parsed = parse(version);
+  if (!parsed)
+    return null;
+  const [first] = parsed.prerelease;
+  if (first === undefined)
+    return "latest";
+  return typeof first === "string" ? first : null;
+}
+var SEMVER;
+var init_semver = __esm(() => {
+  SEMVER = /^(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$/;
+});
+
+// ../registry/src/sort.ts
+function byCodeUnit(a, b) {
+  if (a < b)
+    return -1;
+  return a > b ? 1 : 0;
+}
+
+// ../registry/src/text.ts
+function base64(bytes) {
+  return btoa(String.fromCodePoint(...bytes));
+}
+
+// ../registry/src/build.ts
+function sriFromHex(hexSha256) {
+  if (!hexSha256 || !HEX_SHA256.test(hexSha256))
+    return null;
+  const bytes = hexSha256.match(/../g)?.map((byte) => Number.parseInt(byte, 16)) ?? [];
+  return `sha256-${base64(Uint8Array.from(bytes))}`;
+}
+function tagsOf(entry) {
+  const explicit = some(entry.tags);
+  if (explicit)
+    return explicit;
+  const points = (entry.contributes ?? []).map((c) => c && typeof c === "object" ? c.point : undefined).filter((p) => typeof p === "string").map((p) => p.split("/").pop());
+  return some([...new Set(points)]);
+}
+function metaOf(entry) {
+  return {
+    id: entry.id,
+    name: entry.name,
+    description: entry.description,
+    author: entry.author,
+    homepage: entry.homepage,
+    license: entry.license,
+    keywords: some(entry.keywords),
+    tags: tagsOf(entry),
+    icon: entry.icon
+  };
+}
+function versionOf(entry) {
+  return {
+    schemaVersion: entry.schemaVersion,
+    engines: entry.engines,
+    library: entry.library,
+    dependencies: someMap(dependenciesOf(entry)),
+    optionalDependencies: someMap(optionalDependenciesOf(entry)),
+    definesPoints: some(entry.definesPoints),
+    contributes: some(entry.contributes),
+    consumes: some(entry.consumes),
+    artifacts: entry.artifacts.flatMap((a) => {
+      const integrity = sriFromHex(a.sha256);
+      if (!integrity)
+        return [];
+      return [
+        {
+          target: a.target,
+          url: a.url,
+          size: a.size,
+          integrity,
+          contentHash: sriFromHex(a.contentHash)
+        }
+      ];
+    })
+  };
+}
+function buildModuleRecord(entry, known) {
+  const versions = { ...known?.versions, [entry.version]: versionOf(entry) };
+  const channel = channelOf(entry.version);
+  const distTags = { ...known?.distTags, ...channel ? { [channel]: entry.version } : {} };
+  return {
+    apiVersion: REGISTRY_API_VERSION,
+    ...metaOf(entry),
+    latest: distTags.latest ?? entry.version,
+    distTags,
+    versions
+  };
+}
+function buildIndex(entries) {
+  return entries.map((entry) => ({ ...metaOf(entry), version: entry.version, ...versionOf(entry) })).sort((a, b) => byCodeUnit(a.id, b.id));
+}
+function buildDescriptor(name, url, entries) {
+  return {
+    apiVersion: REGISTRY_API_VERSION,
+    name,
+    url,
+    modules: entries.map((e) => e.id).sort(byCodeUnit)
+  };
+}
+var HEX_SHA256, some = (list) => list && list.length > 0 ? list : undefined, someMap = (map) => Object.keys(map).length > 0 ? map : undefined;
+var init_build = __esm(() => {
+  init_documents();
+  init_manifest();
+  init_semver();
+  HEX_SHA256 = /^[0-9a-f]{64}$/i;
+});
+
+// ../registry/src/client.ts
+var init_client = __esm(() => {
+  init_documents();
+  init_semver();
+});
+
+// ../registry/src/spec.ts
+import { z as z3 } from "zod";
+function openWorld(node) {
+  if (Array.isArray(node))
+    return node.map(openWorld);
+  if (!node || typeof node !== "object")
+    return node;
+  const out = {};
+  for (const [key, value] of Object.entries(node)) {
+    if (key === "additionalProperties" && value === false)
+      continue;
+    out[key] = openWorld(value);
+  }
+  return out;
+}
+function schemaFor(name, version) {
+  if (name === "manifest")
+    return MANIFEST_SCHEMAS[version];
+  return DOCUMENT_SCHEMAS[version]?.[name];
+}
+function jsonSchema(name, version = schemaVersionOf(name), origin = "https://modules.kroma.tv") {
+  const schema = schemaFor(name, version);
+  if (!schema)
+    return null;
+  const emitted = openWorld(z3.toJSONSchema(schema, { io: "output" }));
+  return { ...emitted, $id: `${origin}${schemaPath(name, version)}` };
+}
+var SCHEMA_NAMES, schemaVersionOf = (name) => name === "manifest" ? MODULE_SCHEMA_VERSION : REGISTRY_API_VERSION, schemaPath = (name, version = schemaVersionOf(name)) => `/schemas/${version}/${name}.json`;
+var init_spec = __esm(() => {
+  init_documents();
+  init_manifest();
+  SCHEMA_NAMES = ["manifest", "registry", "index", "module"];
+});
+
+// ../registry/src/index.ts
+var init_src = __esm(() => {
+  init_build();
+  init_client();
+  init_documents();
+  init_manifest();
+  init_semver();
+  init_spec();
+});
+
+// ../module-sdk/src/shared.ts
+function sharedKey(specifier) {
+  if (specifier === PUBLIC_NAME)
+    return "@kroma/module-sdk";
+  if (SHARED_MODULES.includes(specifier))
+    return specifier;
+  if (CLIENT_DOMAIN.test(specifier))
+    return specifier;
+  if (KIT_DEEP.test(specifier))
+    return "@kroma/ui/kit";
+  return null;
+}
+var SHARED_MODULES, CLIENT_DOMAIN, KIT_DEEP, PUBLIC_NAME = "@kromatv/sdk", SHARED_GLOBAL = "__KROMA_SHARED__", REMOTE_ENTRY = "remoteEntry.js", REMOTE_STYLES = "style.css";
+var init_shared = __esm(() => {
+  SHARED_MODULES = [
+    "react",
+    "react/jsx-runtime",
+    "react/jsx-dev-runtime",
+    "react-dom",
+    "react-native",
+    "@kroma/module-sdk",
+    "@kroma/ui",
+    "@kroma/ui/kit",
+    "@kroma/ui/tokens",
+    "@kroma/core",
+    "@kroma/core/react",
+    "@kroma/client",
+    "@kroma/client/query",
+    "@kroma/i18n",
+    "@kroma/i18n/react",
+    "@tanstack/react-query",
+    "@tanstack/react-router",
+    "react-call"
+  ];
+  CLIENT_DOMAIN = /^@kroma\/client\/[a-z][a-z0-9-]*$/;
+  KIT_DEEP = /^@kroma\/ui\/kit\/.+/;
+});
+
+// src/scaffold/plan.ts
+import { existsSync, readFileSync } from "fs";
+import { dirname, join } from "path";
+import { z as z4 } from "zod";
+function packageRoot(from) {
+  let dir = from;
+  for (;; ) {
+    const manifest = join(dir, "package.json");
+    if (existsSync(manifest) && OWN_NAMES.has(JSON.parse(readFileSync(manifest, "utf8")).name)) {
+      return dir;
+    }
+    const parent = dirname(dir);
+    if (parent === dir)
+      throw new Error("kroma: cannot find my own package.json");
+    dir = parent;
+  }
+}
+function slugOf(id) {
+  return id.split(".").pop() ?? id;
+}
+function pascal(slug) {
+  return slug.split(/[^a-z0-9]+/i).filter(Boolean).map((w) => w[0]?.toUpperCase() + w.slice(1)).join("");
+}
+function snake(slug) {
+  return slug.replace(/[^a-z0-9]+/gi, "_").toLowerCase();
+}
+function versions(cwd) {
+  const own = PackageJson.parse(JSON.parse(readFileSync(join(CLI_ROOT, "package.json"), "utf8")));
+  const repo = repoRoot(cwd);
+  const server = repo ? serverVersion(repo) : null;
+  const sdk = own.version !== "0.0.0" ? own.version : server ?? "0.0.0";
+  const channel = repo ? rustChannel(repo) : null;
+  return {
+    sdk,
+    server: server ?? sdk,
+    rustChannel: channel ?? "1.98.0",
+    reactNative: own.kroma.reactNative
+  };
+}
+function repoRoot(cwd) {
+  let dir = cwd;
+  for (;; ) {
+    if (existsSync(join(dir, "server", "Cargo.toml")) && existsSync(join(dir, "modules")))
+      return dir;
+    const parent = dirname(dir);
+    if (parent === dir)
+      return null;
+    dir = parent;
+  }
+}
+function serverVersion(repo) {
+  const toml = readFileSync(join(repo, "server", "Cargo.toml"), "utf8");
+  return /^version\s*=\s*"([^"]+)"/m.exec(toml)?.[1] ?? null;
+}
+function rustChannel(repo) {
+  const path = join(repo, "rust-toolchain.toml");
+  if (!existsSync(path))
+    return null;
+  return /^channel\s*=\s*"([^"]+)"/m.exec(readFileSync(path, "utf8"))?.[1] ?? null;
+}
+function serverRange(version) {
+  return version === "0.0.0" ? "*" : `>=${version}`;
+}
+function sdkSpec(v, inRepo) {
+  if (inRepo)
+    return "workspace:*";
+  return v.sdk === "0.0.0" ? "*" : `^${v.sdk}`;
+}
+function treesFor(kind) {
+  const trees = ["base"];
+  if (kind !== "server")
+    trees.push("ui");
+  if (kind !== "ui")
+    trees.push("server");
+  return trees.map((t) => join(CLI_ROOT, "templates", t));
+}
+function skipInRepo(rel) {
+  return rel === "rust-toolchain.toml" || rel === ".cargo/config.toml" || rel === ".gitignore";
+}
+function templateVars(a, v) {
+  const slug = slugOf(a.id);
+  const crate = `kroma-module-${slug}`;
+  const migrations = a.storage ? `
+    fn migrations(&self) -> &'static str {
+        "CREATE TABLE IF NOT EXISTS notes (id INTEGER PRIMARY KEY, body TEXT NOT NULL);"
+    }
+` : "";
+  return {
+    ID: a.id,
+    SDK: a.inRepo ? "@kroma/module-sdk" : PUBLIC_NAME,
+    SLUG: slug,
+    NAME: a.name,
+    DESCRIPTION: a.description,
+    VERSION: "0.1.0",
+    PAGE: `${pascal(slug)}Page`,
+    STRUCT: `${pascal(slug)}Module`,
+    CRATE: crate,
+    CRATE_IDENT: snake(crate),
+    SDK_CRATES: a.inRepo ? "../../../server/crates" : `../node_modules/${PUBLIC_NAME}/rust`,
+    SDK_FEATURES: a.storage ? ', features = ["storage"]' : "",
+    RUNTIME_FEATURES: a.storage ? ', features = ["storage"]' : "",
+    MIGRATIONS: migrations,
+    RUST_CHANNEL: v.rustChannel
+  };
+}
+function manifestFor(a, v) {
+  const manifest = {
+    $schema: `https://modules.kroma.tv/schemas/${MODULE_SCHEMA_VERSION}/manifest.json`,
+    schemaVersion: MODULE_SCHEMA_VERSION,
+    id: a.id,
+    name: a.name,
+    version: "0.1.0",
+    description: a.description,
+    engines: { server: serverRange(v.server) }
+  };
+  if (a.kind !== "server")
+    manifest.feRemote = { module: "./remoteEntry.js" };
+  if (a.storage)
+    manifest.storage = { core: {} };
+  return manifest;
+}
+function packageJsonFor(a, v) {
+  if (a.kind === "server")
+    return null;
+  const dep = sdkSpec(v, a.inRepo);
+  const slug = slugOf(a.id);
+  return {
+    name: a.inRepo ? `@kroma/module-${slug}` : a.id,
+    version: "0.0.0",
+    private: true,
+    type: "module",
+    description: a.description,
+    ...a.inRepo ? { exports: { ".": "./ui/src/module.tsx", "./schemas": "./ui/src/schemas.ts" } } : {},
+    scripts: a.inRepo ? { typecheck: "tsc --noEmit" } : { dev: "kroma dev", build: "kroma build", check: "kroma check", typecheck: "tsc --noEmit" },
+    dependencies: {
+      ...a.inRepo ? { "@kroma/module-sdk": "workspace:*", "@kroma/ui": "workspace:*" } : { [PUBLIC_NAME]: dep },
+      zod: "^4.5.4"
+    },
+    peerDependencies: { react: "^19.2.8" },
+    devDependencies: {
+      ...a.inRepo ? {} : { react: "^19.2.8", "react-native": v.reactNative },
+      "@types/react": "^19.2.18",
+      typescript: "^7.0.2"
+    },
+    ...a.inRepo ? {} : { overrides: { "react-native": v.reactNative } }
+  };
+}
+function tsconfigFor(a, depth) {
+  if (a.kind === "server")
+    return null;
+  const base = a.inRepo ? `${"../".repeat(depth)}tsconfig.base.json` : `${PUBLIC_NAME}/tsconfig`;
+  return {
+    extends: base,
+    ...a.inRepo ? { compilerOptions: { noEmit: true, types: ["react"] } } : {},
+    include: ["ui/src"]
+  };
+}
+var OWN_NAMES, CLI_ROOT, PackageJson;
+var init_plan = __esm(() => {
+  init_shared();
+  init_src();
+  OWN_NAMES = new Set(["@kroma/cli", PUBLIC_NAME]);
+  CLI_ROOT = packageRoot(import.meta.dir);
+  PackageJson = z4.object({
+    version: z4.string(),
+    kroma: z4.object({ reactNative: z4.string() })
+  });
+});
+
+// src/scaffold/render.ts
+import { mkdirSync, readdirSync, readFileSync as readFileSync2, writeFileSync } from "fs";
+import { dirname as dirname2, join as join2, relative } from "path";
+function render(text, vars) {
+  return text.replace(/__([A-Z_]+)__/g, (all, key) => vars[key] ?? all);
+}
+function outputName(name) {
+  return name.startsWith("_") ? `.${name.slice(1)}` : name;
+}
+function files(dir) {
+  return readdirSync(dir, { withFileTypes: true, recursive: true }).filter((e) => e.isFile()).map((e) => join2(e.parentPath, e.name));
+}
+function renderTree(templateDir, target, vars) {
+  const written = [];
+  for (const file of files(templateDir)) {
+    const rel = relative(templateDir, file).split("/").map((part) => outputName(render(part, vars))).join("/");
+    const out = join2(target, rel);
+    mkdirSync(dirname2(out), { recursive: true });
+    writeFileSync(out, render(readFileSync2(file, "utf8"), vars));
+    written.push(rel);
+  }
+  return written;
+}
+var init_render = () => {};
+
+// src/style.ts
+var CSI = "\x1B[", enabled, wrap = (code) => (text) => enabled ? `${CSI}${code}m${text}${CSI}0m` : text, style;
+var init_style = __esm(() => {
+  enabled = process.stdout.isTTY === true && !process.env.NO_COLOR;
+  style = {
+    bold: wrap("1"),
+    dim: wrap("2"),
+    red: wrap("31"),
+    green: wrap("32"),
+    yellow: wrap("33"),
+    cyan: wrap("36")
+  };
+});
+
+// src/commands/create.ts
+var exports_create = {};
+__export(exports_create, {
+  createCommand: () => createCommand
+});
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, readdirSync as readdirSync2, writeFileSync as writeFileSync2 } from "fs";
+import { join as join3, relative as relative2, resolve } from "path";
+import * as p from "@clack/prompts";
+var {$ } = globalThis.Bun;
+function isKind(v) {
+  return v === "full" || v === "server" || v === "ui";
+}
+function isBareId(dir) {
+  return !dir.includes("/") && REVERSE_DNS_ID.test(dir);
+}
+function idIssue(id) {
+  return REVERSE_DNS_ID.test(id) ? undefined : "a reverse-DNS id, lowercase: tv.acme.notes";
+}
+function titleOf(id) {
+  const slug = slugOf(id);
+  return slug.charAt(0).toUpperCase() + slug.slice(1).replace(/-/g, " ");
+}
+async function answer(value) {
+  if (p.isCancel(value))
+    throw new Error("cancelled");
+  return value;
+}
+async function ask(options, cwd) {
+  const inRepo = options.inRepo ?? repoRoot(cwd) !== null;
+  const given = options.id ?? (options.dir && isBareId(options.dir) ? options.dir : undefined);
+  if (options.yes) {
+    if (!given)
+      throw new Error("--yes needs an id: kroma create tv.acme.notes --yes");
+    return {
+      id: given,
+      name: options.name ?? titleOf(given),
+      description: options.description ?? "",
+      kind: isKind(options.kind) ? options.kind : "full",
+      storage: options.storage ?? false,
+      inRepo
+    };
+  }
+  p.intro(`${style.bold("KROMA")} module`);
+  const id = given && !idIssue(given) ? given : await answer(await p.text({
+    message: "Module id",
+    placeholder: "tv.acme.notes",
+    initialValue: given,
+    validate: (v) => idIssue(v ?? "")
+  }));
+  const name = options.name ?? await answer(await p.text({ message: "Display name", initialValue: titleOf(id) }));
+  const description = options.description ?? await answer(await p.text({ message: "One line about it", defaultValue: "" }));
+  const kind = isKind(options.kind) ? options.kind : await answer(await p.select({ message: "What is it?", options: KINDS }));
+  const storage = kind === "ui" ? false : options.storage ?? await answer(await p.confirm({
+    message: "Does the sidecar keep its own database?",
+    initialValue: false
+  }));
+  return { id, name, description, kind, storage, inRepo };
+}
+function write(target, rel, value) {
+  writeFileSync2(join3(target, rel), `${JSON.stringify(value, null, 2)}
+`);
+}
+async function createCommand(options) {
+  const cwd = options.cwd ?? process.cwd();
+  const a = await ask(options, cwd);
+  const repo = a.inRepo ? repoRoot(cwd) : null;
+  const explicit = options.dir && !isBareId(options.dir) ? resolve(cwd, options.dir) : null;
+  const target = explicit ?? (repo ? join3(repo, "modules", a.id) : join3(cwd, a.id));
+  if (existsSync2(target) && readdirSync2(target).length > 0) {
+    throw new Error(`${target} exists and is not empty`);
+  }
+  mkdirSync2(target, { recursive: true });
+  const v = versions(cwd);
+  const vars = templateVars(a, v);
+  const written = [];
+  for (const tree of treesFor(a.kind)) {
+    for (const rel of renderTree(tree, target, vars)) {
+      if (a.inRepo && skipInRepo(rel)) {
+        await $`rm -f ${join3(target, rel)}`.quiet();
+        continue;
+      }
+      written.push(rel);
+    }
+  }
+  write(target, "module.json", manifestFor(a, v));
+  written.push("module.json");
+  const pkg = packageJsonFor(a, v);
+  if (pkg) {
+    write(target, "package.json", pkg);
+    write(target, "tsconfig.json", tsconfigFor(a, repo ? relative2(repo, target).split("/").length : 0));
+    written.push("package.json", "tsconfig.json");
+  }
+  const where = relative2(cwd, target) || ".";
+  if (options.yes) {
+    console.log(`created ${a.id} in ${where} (${written.length} files)`);
+  } else {
+    p.log.success(`${a.id} in ${where}`);
+  }
+  const install = options.install !== false && pkg !== null;
+  if (install) {
+    const s = options.yes ? null : p.spinner();
+    s?.start(a.inRepo ? "bun install (workspace links)" : "bun install");
+    const result = await $`bun install`.cwd(repo ?? target).quiet().nothrow();
+    if (result.exitCode !== 0) {
+      s?.stop("bun install failed");
+      console.error(result.stderr.toString());
+      return 1;
+    }
+    s?.stop("installed");
+  }
+  const next = [
+    ...where === "." ? [] : [`cd ${where}`],
+    ...a.inRepo ? [] : ["bunx kroma login http://localhost:4040"],
+    a.inRepo ? "bunx kroma dev" : "bunx kroma dev"
+  ];
+  if (options.yes) {
+    console.log(next.join(`
+`));
+  } else {
+    p.note(next.join(`
+`), "next");
+    p.outro("done");
+  }
+  return 0;
+}
+var KINDS;
+var init_create = __esm(() => {
+  init_src();
+  init_plan();
+  init_render();
+  init_style();
+  KINDS = [
+    {
+      value: "full",
+      label: "A page and a sidecar",
+      hint: "a React page in the admin, a Rust process behind it"
+    },
+    { value: "server", label: "A sidecar only", hint: "a Rust process, no page" },
+    { value: "ui", label: "A page only", hint: "a React page over the core API" }
+  ];
+});
+
+// src/sort.ts
+function byCodeUnit2(a, b) {
+  if (a < b)
+    return -1;
+  return a > b ? 1 : 0;
+}
+
+// src/bundle/tar.ts
+import { readdirSync as readdirSync3, readFileSync as readFileSync3, statSync } from "fs";
+import { join as join4 } from "path";
+function octal(value, width) {
+  return `${value.toString(8).padStart(width - 1, "0")}\x00`;
+}
+function header(name, size, mode, dir) {
+  if (name.length > 100) {
+    throw new Error(`tar entry name too long for a ustar header: ${name}`);
+  }
+  const buf = new Uint8Array(BLOCK);
+  const put = (s, off) => buf.set(new TextEncoder().encode(s), off);
+  put(name, 0);
+  put(octal(mode, 8), 100);
+  put(octal(0, 8), 108);
+  put(octal(0, 8), 116);
+  put(octal(dir ? 0 : size, 12), 124);
+  put(octal(0, 12), 136);
+  put("        ", 148);
+  put(dir ? "5" : "0", 156);
+  put("ustar\x00", 257);
+  put("00", 263);
+  let sum = 0;
+  for (const b of buf)
+    sum += b;
+  put(`${sum.toString(8).padStart(6, "0")}\x00 `, 148);
+  return buf;
+}
+function entryList(staging, entries) {
+  const out = [];
+  const walk = (rel) => {
+    if (statSync(join4(staging, rel)).isDirectory()) {
+      out.push({ name: `${rel}/`, dir: true, mode: 493 });
+      for (const child of readdirSync3(join4(staging, rel)).sort(byCodeUnit2)) {
+        walk(`${rel}/${child}`);
+      }
+    } else {
+      out.push({ name: rel, dir: false, mode: rel === "module" ? 493 : 420 });
+    }
+  };
+  for (const entry of [...entries].sort(byCodeUnit2))
+    walk(entry);
+  return out;
+}
+function deterministicTar(staging, entries) {
+  const parts = [];
+  for (const e of entryList(staging, entries)) {
+    if (e.dir) {
+      parts.push(header(e.name, 0, e.mode, true));
+      continue;
+    }
+    const data = readFileSync3(join4(staging, e.name));
+    parts.push(header(e.name, data.length, e.mode, false), data);
+    const pad = data.length % BLOCK;
+    if (pad)
+      parts.push(new Uint8Array(BLOCK - pad));
+  }
+  parts.push(new Uint8Array(BLOCK * 2));
+  const buf = new Uint8Array(parts.reduce((n, p2) => n + p2.length, 0));
+  let off = 0;
+  for (const p2 of parts) {
+    buf.set(p2, off);
+    off += p2.length;
+  }
+  return buf;
+}
+function tarRead(tar, wanted) {
+  const field = (start, len) => new TextDecoder().decode(tar.subarray(start, start + len)).split("\x00")[0] ?? "";
+  let off = 0;
+  while (off + BLOCK <= tar.length) {
+    const name = field(off, 100);
+    if (!name)
+      break;
+    const size = Number.parseInt(field(off + 124, 12).trim() || "0", 8);
+    if (name === wanted || name === `./${wanted}`) {
+      return tar.subarray(off + BLOCK, off + BLOCK + size);
+    }
+    off += BLOCK + Math.ceil(size / BLOCK) * BLOCK;
+  }
+  return null;
+}
+function toTar(buf) {
+  if (buf[0] === 40 && buf[1] === 181 && buf[2] === 47 && buf[3] === 253) {
+    return Bun.zstdDecompressSync(buf);
+  }
+  if (buf[0] === 31 && buf[1] === 139) {
+    return Bun.gunzipSync(buf);
+  }
+  return buf;
+}
+var BLOCK = 512;
+var init_tar = () => {};
+
+// src/bundle/pack.ts
+import {
+  copyFileSync,
+  cpSync,
+  existsSync as existsSync3,
+  mkdirSync as mkdirSync3,
+  readFileSync as readFileSync4,
+  rmSync,
+  writeFileSync as writeFileSync3
+} from "fs";
+import { join as join5 } from "path";
+function bundleName(id, hasBinary, target) {
+  return `${id}${hasBinary && target ? `-${target}` : ""}.kmod`;
+}
+function stage(input) {
+  const { project, binPath, feDir } = input;
+  const staging = join5(project.dir, ".bundle");
+  rmSync(staging, { recursive: true, force: true });
+  mkdirSync3(staging, { recursive: true });
+  const entries = ["module.json"];
+  copyFileSync(join5(project.dir, "module.json"), join5(staging, "module.json"));
+  if (binPath) {
+    copyFileSync(binPath, join5(staging, "module"));
+    entries.push("module");
+  }
+  for (const icon of ["icon.svg", "icon.png"]) {
+    if (existsSync3(join5(project.dir, icon))) {
+      copyFileSync(join5(project.dir, icon), join5(staging, icon));
+      entries.push(icon);
+    }
+  }
+  if (feDir && existsSync3(feDir)) {
+    cpSync(feDir, join5(staging, "fe"), { recursive: true });
+    entries.push("fe");
+  }
+  return { staging, entries };
+}
+function packBundle(input) {
+  const { project, outDir, target, binPath } = input;
+  const { staging, entries } = stage(input);
+  mkdirSync3(outDir, { recursive: true });
+  const file = bundleName(project.manifest.id, binPath !== null, target);
+  const kmod = join5(outDir, file);
+  const tar = deterministicTar(staging, entries);
+  rmSync(staging, { recursive: true, force: true });
+  const stamp = `${kmod}.tarsha`;
+  const tarSha = Bun.SHA256.hash(tar, "hex");
+  if (existsSync3(kmod) && existsSync3(stamp) && readFileSync4(stamp, "utf8").trim() === tarSha) {
+    return { path: kmod, file, changed: false };
+  }
+  const bytes = Bun.zstdCompressSync(tar, { level: 19 });
+  writeFileSync3(kmod, bytes);
+  writeFileSync3(stamp, `${tarSha}
+`);
+  writeFileSync3(`${kmod}.sha256`, `${Bun.SHA256.hash(bytes, "hex")}  ${file}
+`);
+  return { path: kmod, file, changed: true };
+}
+function packForDev(input) {
+  const { project, outDir, target, binPath } = input;
+  const { staging, entries } = stage(input);
+  mkdirSync3(outDir, { recursive: true });
+  const file = bundleName(project.manifest.id, binPath !== null, target);
+  const kmod = join5(outDir, file);
+  const tar = deterministicTar(staging, entries);
+  rmSync(staging, { recursive: true, force: true });
+  writeFileSync3(kmod, Bun.zstdCompressSync(tar, { level: 1 }));
+  return { path: kmod, file, changed: true };
+}
+var init_pack = __esm(() => {
+  init_tar();
+});
+
+// src/cargo.ts
+import { existsSync as existsSync4 } from "fs";
+import { join as join6 } from "path";
+var {$: $2 } = globalThis.Bun;
+function targetDir(cwd, projects) {
+  const env = process.env.KMOD_TARGET_DIR?.trim();
+  if (env)
+    return env;
+  const only = projects[0];
+  if (projects.length === 1 && only?.dir === cwd)
+    return join6(only.dir, "server/target");
+  return join6(cwd, "target/kmod");
+}
+function cargoBuild(bin, features, target, profile, dir) {
+  const args = ["build", "--bin", bin];
+  if (profile === "release-kmod")
+    args.push("--profile", "release-kmod");
+  if (features.length)
+    args.push("--features", features.join(","));
+  if (target)
+    args.push("--target", target);
+  const outDir = profile === "release-kmod" ? "release-kmod" : "debug";
+  const binPath = target ? join6(dir, target, outDir, bin) : join6(dir, outDir, bin);
+  return { args, binPath };
+}
+async function cargo(cwd, args, dir, quiet = false) {
+  const run = $2`cargo ${args}`.cwd(cwd).env({ ...process.env, CARGO_TARGET_DIR: dir }).nothrow();
+  const result = quiet ? await run.quiet() : await run;
+  return result.exitCode;
+}
+async function buildSidecar(project, dir, options) {
+  const server = project.server;
+  if (!server?.bin)
+    return null;
+  const { args, binPath } = cargoBuild(server.bin, server.features, options.target, options.profile, dir);
+  if (!options.skipBuild) {
+    const code = await cargo(server.dir, args, dir);
+    if (code !== 0)
+      throw new Error(`${project.manifest.id}: cargo build failed`);
+  }
+  if (!existsSync4(binPath)) {
+    throw new Error(options.skipBuild ? `KMOD_SKIP_BUILD is set but there is no prebuilt binary at ${binPath}` : `${project.manifest.id}: cargo built no binary at ${binPath}`);
+  }
+  return binPath;
+}
+var init_cargo = () => {};
+
+// src/fe/remote-plugin.ts
+import { dirname as dirname3, relative as relative3 } from "path";
+import { init, parse as parse2 } from "es-module-lexer";
+import MagicString from "magic-string";
+function posix(path) {
+  return path.split("\\").join("/");
+}
+function relativeImport(from, to) {
+  const rel = posix(relative3(dirname3(from), to));
+  return rel.startsWith(".") ? rel : `./${rel}`;
+}
+function clean(id) {
+  return id.split("?", 1)[0] ?? id;
+}
+function pattern(braces) {
+  const fields = braces.slice(1, -1).split(",").map((s) => s.trim()).filter(Boolean).map((s) => {
+    const [name, alias] = s.split(/\s+as\s+/);
+    return alias ? `${name}: ${alias}` : String(name);
+  });
+  return `{ ${fields.join(", ")} }`;
+}
+function rewriteImport(statement, key, tmp) {
+  const take = `const ${tmp} = ${HELPER_FN}(${JSON.stringify(key)});`;
+  if (/^import\s*['"]/.test(statement))
+    return `${HELPER_FN}(${JSON.stringify(key)});`;
+  const clause = /^import\s+([\s\S]*?)\s*from\s*['"]/.exec(statement)?.[1];
+  if (clause === undefined)
+    throw new Error(`cannot rewrite: ${statement}`);
+  const lines = [take];
+  let rest = clause.trim();
+  const braces = /\{[^}]*\}/.exec(rest)?.[0];
+  if (braces) {
+    lines.push(`const ${pattern(braces)} = ${tmp};`);
+    rest = rest.replace(braces, "");
+  }
+  const ns = /\*\s+as\s+(\w+)/.exec(rest)?.[1];
+  if (ns) {
+    lines.push(`const ${ns} = ${tmp};`);
+    rest = rest.replace(/\*\s+as\s+\w+/, "");
+  }
+  const def = rest.replace(/,/g, "").trim();
+  if (def)
+    lines.push(`const ${def} = ${tmp}.default;`);
+  return lines.join(" ");
+}
+function rewriteReexport(statement, key, tmp) {
+  const take = `const ${tmp} = ${HELPER_FN}(${JSON.stringify(key)});`;
+  const braces = /\{[^}]*\}/.exec(statement)?.[0];
+  if (!braces) {
+    throw new Error(`\`export * from '${key}'\` is not supported for a package the host provides`);
+  }
+  const fields = braces.slice(1, -1).split(",").map((s) => s.trim()).filter(Boolean).map((s) => {
+    const [name, alias] = s.split(/\s+as\s+/);
+    return `export const ${alias ?? name} = ${tmp}.${name};`;
+  });
+  return [take, ...fields].join(" ");
+}
+function kromaRemote(options) {
+  const entry = posix(options.entry);
+  const manifestImport = relativeImport(options.entry, options.manifestPath);
+  const localesGlob = `${relativeImport(options.entry, options.localesDir)}/*.json`;
+  const manifest = {
+    name: "kroma-remote:manifest",
+    enforce: "pre",
+    transform(code, id) {
+      if (posix(clean(id)) !== entry || !OPTIONS_ONLY_CALL.test(code))
+        return null;
+      const injected = `import __kromaManifest from '${manifestImport}';
+${code}`.replace(OPTIONS_ONLY_CALL, `defineModule({ manifest: __kromaManifest, locales: import.meta.glob('${localesGlob}', { eager: true, import: 'default' }),`);
+      return { code: injected, map: null };
+    }
+  };
+  const shared = {
+    name: "kroma-remote:shared",
+    enforce: "post",
+    resolveId(id, importer) {
+      if (id === HELPER)
+        return RESOLVED_HELPER;
+      const key = sharedKey(id);
+      if (key)
+        return { id: `${HELPER}:${key}`, external: true };
+      if (id.startsWith("@kroma/")) {
+        this.error(`${importer ?? "a module file"} imports '${id}', which the host does not provide. The SDK packages carry types only; a page may import ${SHARED_MODULES.join(", ")} and any @kroma/client/<domain>.`);
+      }
+      return null;
+    },
+    load(id) {
+      if (id !== RESOLVED_HELPER)
+        return null;
+      return [
+        `export function ${HELPER_FN}(key) {`,
+        `  const shared = globalThis[${JSON.stringify(SHARED_GLOBAL)}];`,
+        "  const mod = shared && shared[key];",
+        '  if (!mod) throw new Error("kroma module: the host provides no " + JSON.stringify(key) + "; this bundle only runs inside a KROMA client");',
+        "  return mod;",
+        "}"
+      ].join(`
+`);
+    },
+    async transform(code, id) {
+      const file = clean(id);
+      if (id.startsWith("\x00") || !SCRIPT.test(file))
+        return null;
+      if (!code.includes("import") && !code.includes("export"))
+        return null;
+      await init;
+      const [imports, exports] = parse2(code, file);
+      if (posix(file) === entry && !exports.some((e) => e.n === "default")) {
+        this.error(`${file}: the module entry must \`export default defineModule({ ... })\``);
+      }
+      const s = new MagicString(code);
+      let count = 0;
+      for (const imp of imports) {
+        if (!imp.n)
+          continue;
+        const key = sharedKey(imp.n);
+        if (!key)
+          continue;
+        const tmp = `__ks${count++}`;
+        if (imp.d >= 0) {
+          s.overwrite(imp.ss, imp.se, `Promise.resolve(${HELPER_FN}(${JSON.stringify(key)}))`);
+          continue;
+        }
+        const statement = code.slice(imp.ss, imp.se);
+        const rewritten = statement.startsWith("export") ? rewriteReexport(statement, key, tmp) : rewriteImport(statement, key, tmp);
+        s.overwrite(imp.ss, imp.se, rewritten);
+      }
+      if (count === 0)
+        return null;
+      s.prepend(`import { ${HELPER_FN} } from ${JSON.stringify(HELPER)};
+`);
+      return { code: s.toString(), map: s.generateMap({ hires: true }) };
+    },
+    generateBundle(_options, bundle) {
+      if (!(REMOTE_STYLES in bundle))
+        return;
+      const entry2 = bundle[REMOTE_ENTRY];
+      if (entry2?.type !== "chunk")
+        return;
+      entry2.code = `${LINK_STYLES}
+${entry2.code}`;
+    }
+  };
+  return [manifest, shared];
+}
+var HELPER = "virtual:kroma-shared", RESOLVED_HELPER, HELPER_FN = "__kroma_shared", OPTIONS_ONLY_CALL, LINK_STYLES, SCRIPT;
+var init_remote_plugin = __esm(() => {
+  init_shared();
+  RESOLVED_HELPER = `\x00${HELPER}`;
+  OPTIONS_ONLY_CALL = /\bdefineModule\s*\(\s*\{/;
+  LINK_STYLES = [
+    "(function () {",
+    `  var href = new URL(${JSON.stringify(`./${REMOTE_STYLES}`)}, import.meta.url).href;`,
+    `  if (document.querySelector('link[href="' + href + '"]')) return;`,
+    "  var link = document.createElement('link');",
+    "  link.rel = 'stylesheet';",
+    "  link.href = href;",
+    "  document.head.appendChild(link);",
+    "})();"
+  ].join(`
+`);
+  SCRIPT = /\.[cm]?[jt]sx?$/;
+});
+
+// src/fe/build.ts
+import { join as join7 } from "path";
+import { build } from "vite";
+async function buildFrontend(project, outDir, mode) {
+  const ui = project.ui;
+  if (!ui)
+    return false;
+  await build({
+    configFile: false,
+    envDir: false,
+    root: ui.dir,
+    mode,
+    logLevel: "warn",
+    clearScreen: false,
+    define: { "process.env.NODE_ENV": JSON.stringify(mode) },
+    plugins: kromaRemote({
+      entry: ui.entry,
+      manifestPath: join7(project.dir, "module.json"),
+      localesDir: join7(project.dir, "locales")
+    }),
+    build: {
+      outDir,
+      emptyOutDir: true,
+      target: "es2022",
+      minify: mode === "production",
+      sourcemap: mode === "development",
+      cssCodeSplit: false,
+      lib: {
+        entry: ui.entry,
+        formats: ["es"],
+        fileName: () => REMOTE_ENTRY,
+        cssFileName: REMOTE_STYLES.replace(/\.css$/, "")
+      },
+      rolldownOptions: {
+        output: {
+          chunkFileNames: "[name]-[hash].js",
+          assetFileNames: "[name]-[hash][extname]"
+        }
+      }
+    }
+  });
+  return true;
+}
+var init_build2 = __esm(() => {
+  init_shared();
+  init_remote_plugin();
+});
+
+// src/project.ts
+import { existsSync as existsSync5, readdirSync as readdirSync4, readFileSync as readFileSync5, statSync as statSync2 } from "fs";
+import { isAbsolute, join as join8, resolve as resolve2 } from "path";
+import { z as z5 } from "zod";
+function readServer(dir) {
+  const serverDir = join8(dir, "server");
+  const cargoPath = join8(serverDir, "Cargo.toml");
+  if (!existsSync5(cargoPath))
+    return null;
+  const cargo2 = CargoManifest.parse(Bun.TOML.parse(readFileSync5(cargoPath, "utf8")));
+  return {
+    dir: serverDir,
+    crate: cargo2.package.name,
+    bin: cargo2.bin[0]?.name ?? null,
+    features: cargo2.package.metadata?.kmod?.features ?? []
+  };
+}
+function readFrontend(dir) {
+  const entry = UI_ENTRIES.map((rel) => join8(dir, rel)).find((p2) => existsSync5(p2));
+  return entry ? { dir: join8(dir, "ui"), entry } : null;
+}
+function issues(error) {
+  return error.issues.map((i) => `  ${i.path.length ? `${i.path.join(".")}: ` : ""}${i.message}`).join(`
+`);
+}
+function openProject(dir) {
+  const path = join8(dir, "module.json");
+  if (!existsSync5(path)) {
+    throw new Error(`${dir} is not a module: no module.json there`);
+  }
+  let raw;
+  try {
+    raw = JSON.parse(readFileSync5(path, "utf8"));
+  } catch (e) {
+    throw new Error(`${path}: invalid JSON (${e.message})`);
+  }
+  const read = AuthoredManifest.safeParse(raw);
+  if (!read.success) {
+    throw new Error(`${path} is not a valid manifest:
+${issues(read.error)}`);
+  }
+  return { dir, manifest: read.data, server: readServer(dir), ui: readFrontend(dir) };
+}
+function absolute(path, cwd) {
+  return isAbsolute(path) ? path : resolve2(cwd, path);
+}
+function moduleDirs(root) {
+  if (!existsSync5(root))
+    return [];
+  return readdirSync4(root, { withFileTypes: true }).filter((e) => e.isDirectory() && existsSync5(join8(root, e.name, "module.json"))).map((e) => join8(root, e.name)).sort(byCodeUnit2);
+}
+function findProjects(dirs, cwd = process.cwd()) {
+  if (dirs.length > 0)
+    return dirs.map((d) => openProject(absolute(d, cwd)));
+  if (existsSync5(join8(cwd, "module.json")))
+    return [openProject(cwd)];
+  const found = moduleDirs(join8(cwd, "modules"));
+  if (found.length === 0) {
+    throw new Error(`no module here: ${cwd} has no module.json and no modules/ directory`);
+  }
+  return found.map(openProject);
+}
+var AuthoredManifest, CargoManifest, UI_ENTRIES;
+var init_project = __esm(() => {
+  init_src();
+  AuthoredManifest = Manifest.strict().refine((m) => m.schemaVersion === MODULE_SCHEMA_VERSION, {
+    message: `schemaVersion must be ${MODULE_SCHEMA_VERSION}`
+  }).refine((m) => REVERSE_DNS_ID.test(m.id), { message: "id must be reverse-DNS, lowercase" });
+  CargoManifest = z5.object({
+    package: z5.object({
+      name: z5.string(),
+      metadata: z5.object({ kmod: z5.object({ features: z5.array(z5.string()).default([]) }).optional() }).optional()
+    }),
+    bin: z5.array(z5.object({ name: z5.string() })).default([])
+  });
+  UI_ENTRIES = ["ui/src/module.tsx", "ui/src/module.ts", "ui/src/index.tsx", "ui/src/index.ts"];
+});
+
+// src/config.ts
+import { existsSync as existsSync6, mkdirSync as mkdirSync4, readFileSync as readFileSync6, writeFileSync as writeFileSync4 } from "fs";
+import { homedir } from "os";
+import { dirname as dirname4, join as join9 } from "path";
+import { z as z6 } from "zod";
+function configPath() {
+  const env = process.env.KROMA_CLI_CONFIG?.trim();
+  if (env)
+    return env;
+  const base = process.env.XDG_CONFIG_HOME?.trim() || join9(homedir(), ".config");
+  return join9(base, "kroma", "cli.json");
+}
+function readConfig(path = configPath()) {
+  if (!existsSync6(path))
+    return { servers: {} };
+  try {
+    return Config.parse(JSON.parse(readFileSync6(path, "utf8")));
+  } catch {
+    return { servers: {} };
+  }
+}
+function writeConfig(config, path = configPath()) {
+  mkdirSync4(dirname4(path), { recursive: true });
+  writeFileSync4(path, `${JSON.stringify(config, null, 2)}
+`, { mode: 384 });
+}
+function normalizeServer(url) {
+  const withScheme = /^https?:\/\//.test(url) ? url : `http://${url}`;
+  return withScheme.replace(/\/+$/, "");
+}
+var Config;
+var init_config = __esm(() => {
+  Config = z6.object({
+    defaultServer: z6.string().optional(),
+    servers: z6.record(z6.string(), z6.object({ token: z6.string(), user: z6.string().optional() })).default({})
+  });
+});
+
+// src/server.ts
+import { readFileSync as readFileSync7 } from "fs";
+import { z as z7 } from "zod";
+function resolveServer(options) {
+  const config = readConfig();
+  const url = normalizeServer(options.server ?? process.env.KROMA_SERVER ?? config.defaultServer ?? DEFAULT_SERVER);
+  const token = options.token ?? process.env.KROMA_TOKEN ?? config.servers[url]?.token;
+  if (!token) {
+    throw new Error(`no token for ${url}: run \`kroma login ${url}\`, or pass --token / set KROMA_TOKEN (an account with settings.manage)`);
+  }
+  return { url, token };
+}
+function hostTriplePart(arch = process.arch, platform = process.platform) {
+  const cpu = arch === "arm64" ? "aarch64" : "x86_64";
+  const os = platform === "darwin" ? "apple-darwin" : "linux";
+  return `${cpu}-${os === "linux" ? "unknown-linux" : os}`;
+}
+function bundleFor(files2, id, triple = hostTriplePart()) {
+  const mine = files2.filter((f) => f === `${id}.kmod` || f.startsWith(`${id}-`));
+  if (mine.length === 0)
+    return;
+  return mine.find((f) => f === `${id}.kmod`) ?? mine.find((f) => f.includes(triple)) ?? mine[0];
+}
+async function serverPlatform(server) {
+  const res = await fetch(`${server.url}/api/admin/store/platform`, {
+    headers: { authorization: `Bearer ${server.token}` }
+  });
+  if (res.status === 404)
+    return null;
+  if (!res.ok)
+    throw new Error(`${server.url}: GET /api/admin/store/platform failed (${res.status})`);
+  return Platform.parse(await res.json());
+}
+function bundleRunsOn(file, platform) {
+  if (!platform)
+    return true;
+  const stem = file.replace(/\.kmod$/, "");
+  const dash = stem.indexOf("-");
+  if (dash < 0)
+    return true;
+  return stem.slice(dash + 1) === platform.target;
+}
+async function uploadBundle(server, path) {
+  const bytes = readFileSync7(path);
+  const res = await fetch(`${server.url}/api/admin/store/install`, {
+    method: "POST",
+    headers: {
+      authorization: `Bearer ${server.token}`,
+      "content-type": "application/octet-stream"
+    },
+    body: new Uint8Array(bytes.buffer, bytes.byteOffset, bytes.byteLength)
+  });
+  const body = await res.text();
+  if (!res.ok)
+    throw new Error(`install failed (${res.status}): ${body}`);
+  return body;
+}
+var DEFAULT_SERVER = "http://localhost:4040", Platform;
+var init_server = __esm(() => {
+  init_config();
+  Platform = z7.object({ target: z7.string(), serverVersion: z7.string() });
+});
+
+// src/commands/build.ts
+var exports_build = {};
+__export(exports_build, {
+  buildCommand: () => buildCommand,
+  feOutDir: () => feOutDir
+});
+import { join as join10 } from "path";
+function feOutDir(project) {
+  return join10(project.dir, "dist", "fe");
+}
+function describe(project) {
+  const server = project.server;
+  if (!server?.bin)
+    return "library, no binary";
+  const extras = server.features.length ? ` [+${server.features.join(",")}]` : "";
+  return `bin ${server.bin}${extras}`;
+}
+async function buildCommand(options) {
+  const cwd = options.cwd ?? process.cwd();
+  const projects = findProjects(options.dirs, cwd);
+  const dir = targetDir(cwd, projects);
+  const outDir = options.out ?? join10(cwd, "dist", "modules");
+  const target = options.target?.trim() || process.env.KMOD_TARGET?.trim() || null;
+  const profile = options.profile ?? "release-kmod";
+  const skipBuild = options.skipBuild ?? process.env.KMOD_SKIP_BUILD === "1";
+  const built = [];
+  for (const project of projects) {
+    console.log(`
+${style.bold(project.manifest.id)} (${describe(project)})`);
+    built.push({
+      project,
+      binPath: await buildSidecar(project, dir, { target, profile, skipBuild })
+    });
+  }
+  const packed = await Promise.all(built.map(async ({ project, binPath }) => {
+    const fe = feOutDir(project);
+    const hasFe = await buildFrontend(project, fe, "production");
+    const result = packBundle({ project, binPath, feDir: hasFe ? fe : null, outDir, target });
+    console.log(`  ${result.changed ? "packed" : "unchanged"}: ${result.path}`);
+    return result;
+  }));
+  console.log(`
+${packed.length} bundle(s) in ${outDir}`);
+  return 0;
+}
+var init_build3 = __esm(() => {
+  init_pack();
+  init_cargo();
+  init_build2();
+  init_project();
+  init_style();
+});
+
+// src/commands/dev.ts
+var exports_dev = {};
+__export(exports_dev, {
+  devCommand: () => devCommand
+});
+import { existsSync as existsSync7, watch } from "fs";
+import { join as join11, relative as relative4 } from "path";
+function partOf(project, file) {
+  const rel = relative4(project.dir, file);
+  if (rel.startsWith("..") || rel.startsWith("dist") || rel.startsWith(".bundle"))
+    return null;
+  if (rel.startsWith("server/"))
+    return rel.endsWith(".rs") || rel.endsWith("Cargo.toml") ? "server" : null;
+  if (rel.startsWith("ui/"))
+    return rel.includes("/dist/") || rel.includes("node_modules") ? null : "ui";
+  if (rel.startsWith("locales/") || rel === "module.json")
+    return "ui";
+  if (rel.startsWith("icon."))
+    return "bundle";
+  return null;
+}
+
+class Loop {
+  project;
+  server;
+  dir;
+  target;
+  binPath = null;
+  hasFe = false;
+  running = null;
+  pending = new Set;
+  constructor(project, server, dir, target) {
+    this.project = project;
+    this.server = server;
+    this.dir = dir;
+    this.target = target;
+  }
+  request(parts) {
+    for (const p2 of parts)
+      this.pending.add(p2);
+    if (this.running)
+      return;
+    this.running = this.drain().finally(() => {
+      this.running = null;
+      if (this.pending.size > 0)
+        this.request([]);
+    });
+  }
+  async drain() {
+    const parts = new Set(this.pending);
+    this.pending.clear();
+    const started = Date.now();
+    try {
+      if (parts.has("server")) {
+        this.binPath = await buildSidecar(this.project, this.dir, {
+          target: this.target,
+          profile: "dev"
+        });
+      }
+      if (parts.has("ui")) {
+        this.hasFe = await buildFrontend(this.project, feOutDir(this.project), "development");
+      }
+      const packed = packForDev({
+        project: this.project,
+        binPath: this.binPath,
+        feDir: this.hasFe ? feOutDir(this.project) : null,
+        outDir: join11(this.project.dir, "dist", "dev"),
+        target: this.target
+      });
+      await uploadBundle(this.server, packed.path);
+      console.log(`  ${style.green("installed")} ${packed.file} in ${Date.now() - started}ms`);
+    } catch (e) {
+      console.error(`  ${style.red("failed")}: ${e instanceof Error ? e.message : String(e)}`);
+      console.error("  the running module is left as it was");
+    }
+  }
+}
+async function devCommand(options) {
+  const cwd = options.cwd ?? process.cwd();
+  const project = openProject(options.dir ? join11(cwd, options.dir) : cwd);
+  const server = resolveServer(options);
+  const platform = await serverPlatform(server);
+  const target = options.target?.trim() || null;
+  const host = hostTriplePart();
+  if (platform && !target && !platform.target.startsWith(host)) {
+    throw new Error(`${server.url} runs ${platform.target} and this machine builds ${host}; pass --target ${platform.target}`);
+  }
+  if (platform && target && !bundleRunsOn(`x-${target}.kmod`, platform)) {
+    throw new Error(`${server.url} runs ${platform.target}, not ${target}`);
+  }
+  const dir = targetDir(cwd, [project]);
+  const loop = new Loop(project, server, dir, target);
+  console.log(`${style.bold(project.manifest.id)} -> ${server.url}`);
+  loop.request(["server", "ui"]);
+  const timers = new Map;
+  const roots = [
+    "server/src",
+    "server/Cargo.toml",
+    "ui/src",
+    "locales",
+    "module.json",
+    "icon.svg",
+    "icon.png"
+  ].map((r) => join11(project.dir, r)).filter((r) => existsSync7(r));
+  for (const root of roots) {
+    watch(root, { recursive: true }, (_event, file) => {
+      const part = partOf(project, join11(root, file ?? ""));
+      if (!part)
+        return;
+      clearTimeout(timers.get(part));
+      timers.set(part, setTimeout(() => {
+        console.log(`
+${relative4(project.dir, join11(root, file ?? ""))} changed`);
+        loop.request([part]);
+      }, DEBOUNCE_MS));
+    });
+  }
+  console.log(`watching ${roots.map((r) => relative4(project.dir, r)).join(", ")}
+`);
+  await new Promise(() => {});
+  return 0;
+}
+var DEBOUNCE_MS = 120;
+var init_dev = __esm(() => {
+  init_pack();
+  init_cargo();
+  init_build2();
+  init_project();
+  init_server();
+  init_style();
+  init_build3();
+});
+
+// src/commands/check.ts
+var exports_check = {};
+__export(exports_check, {
+  checkCommand: () => checkCommand,
+  importProblems: () => importProblems
+});
+import { existsSync as existsSync8, readdirSync as readdirSync5, readFileSync as readFileSync8 } from "fs";
+import { dirname as dirname5, join as join12, relative as relative5 } from "path";
+var {$: $3 } = globalThis.Bun;
+function sources(dir) {
+  if (!existsSync8(dir))
+    return [];
+  return readdirSync5(dir, { withFileTypes: true, recursive: true }).filter((e) => e.isFile() && /\.(ts|tsx)$/.test(e.name) && !/\.test\.tsx?$/.test(e.name)).map((e) => join12(e.parentPath, e.name));
+}
+function importProblems(file, code, projectDir) {
+  const out = [];
+  const label = relative5(projectDir, file);
+  for (const m of code.matchAll(IMPORT)) {
+    const spec = m[1] ?? m[2] ?? "";
+    if (spec.startsWith("#ui/")) {
+      out.push(`${label}: '${spec}' is the kit's private alias; import from '@kroma/ui/kit'`);
+    } else if (spec.startsWith(".")) {
+      const target = join12(dirname5(file), spec);
+      if (relative5(projectDir, target).startsWith("..")) {
+        out.push(`${label}: '${spec}' reaches outside the module`);
+      }
+    }
+  }
+  return out;
+}
+async function checkTs(project) {
+  if (!project.ui)
+    return [];
+  const tsconfigDir = [project.dir, project.ui.dir].find((d) => existsSync8(join12(d, "tsconfig.json")));
+  const problems = sources(join12(project.ui.dir, "src")).flatMap((f) => importProblems(f, readFileSync8(f, "utf8"), project.dir));
+  if (!tsconfigDir)
+    return [...problems, `${project.manifest.id}: no tsconfig.json beside the frontend`];
+  const tsc = await $3`bun x tsc --noEmit -p ${tsconfigDir}`.cwd(tsconfigDir).nothrow();
+  if (tsc.exitCode !== 0)
+    problems.push(`${project.manifest.id}: tsc failed`);
+  return problems;
+}
+async function checkCommand(options) {
+  const cwd = options.cwd ?? process.cwd();
+  const projects = findProjects(options.dirs, cwd);
+  const dir = targetDir(cwd, projects);
+  const problems = [];
+  const seen = new Map;
+  for (const p2 of projects) {
+    const first = seen.get(p2.manifest.id);
+    if (first)
+      problems.push(`duplicate module id "${p2.manifest.id}" in ${first} and ${p2.dir}`);
+    seen.set(p2.manifest.id, p2.dir);
+  }
+  for (const project of projects) {
+    console.log(`
+${style.bold(project.manifest.id)}`);
+    if (options.ts !== false)
+      problems.push(...await checkTs(project));
+    if (options.rust !== false && project.server) {
+      const code = await cargo(project.server.dir, ["clippy", "--all-targets", "--", "-D", "warnings"], dir);
+      if (code !== 0)
+        problems.push(`${project.manifest.id}: clippy failed`);
+    }
+  }
+  if (problems.length > 0) {
+    console.error(`
+${style.red(`${problems.length} problem(s)`)}`);
+    for (const p2 of problems)
+      console.error(`  - ${p2}`);
+    return 1;
+  }
+  console.log(`
+${style.green("every check passed")} (${projects.length} module(s))`);
+  return 0;
+}
+var IMPORT;
+var init_check = __esm(() => {
+  init_cargo();
+  init_project();
+  init_style();
+  IMPORT = /^\s*(?:import|export)\b[^'"]*?from\s*['"]([^'"]+)['"]|^\s*import\s*['"]([^'"]+)['"]/gm;
+});
+
+// src/commands/install.ts
+var exports_install = {};
+__export(exports_install, {
+  installCommand: () => installCommand
+});
+import { existsSync as existsSync9, readdirSync as readdirSync6 } from "fs";
+import { basename, join as join13 } from "path";
+function pickBundle(options, cwd, triple) {
+  if (options.file)
+    return options.file;
+  const id = options.id ?? (existsSync9(join13(cwd, "module.json")) ? openProject(cwd).manifest.id : undefined);
+  if (!id)
+    throw new Error("usage: kroma install [module-id] [--file x.kmod] [--server URL] [--token T]");
+  const dir = options.from ?? join13(cwd, "dist", "modules");
+  const file = existsSync9(dir) ? bundleFor(readdirSync6(dir), id, triple) : undefined;
+  if (!file)
+    throw new Error(`no packed bundle for '${id}' in ${dir}; run \`kroma build\` first`);
+  return join13(dir, file);
+}
+async function installCommand(options) {
+  const cwd = options.cwd ?? process.cwd();
+  const server = resolveServer(options);
+  const platform = await serverPlatform(server);
+  const path = pickBundle(options, cwd, platform?.target ?? hostTriplePart());
+  if (!bundleRunsOn(basename(path), platform)) {
+    throw new Error(`${basename(path)} was built for another platform; the server at ${server.url} runs ${platform?.target}. Build with --target ${platform?.target}.`);
+  }
+  const body = await uploadBundle(server, path);
+  console.log(`installed ${basename(path)} -> ${server.url}`);
+  if (body.trim())
+    console.log(`  ${body.trim()}`);
+  return 0;
+}
+var init_install = __esm(() => {
+  init_project();
+  init_server();
+});
+
+// src/commands/login.ts
+var exports_login = {};
+__export(exports_login, {
+  loginCommand: () => loginCommand
+});
+import * as p2 from "@clack/prompts";
+import { z as z8 } from "zod";
+async function ask2(label, given, secret) {
+  if (given)
+    return given;
+  const answer2 = secret ? await p2.password({ message: label }) : await p2.text({ message: label, validate: (v) => v ? undefined : "required" });
+  if (p2.isCancel(answer2))
+    throw new Error("cancelled");
+  return answer2;
+}
+async function loginCommand(options) {
+  const url = normalizeServer(options.server ?? process.env.KROMA_SERVER ?? DEFAULT_SERVER);
+  p2.intro(`sign in to ${url}`);
+  const email = await ask2("email or username", options.email ?? process.env.KROMA_EMAIL, false);
+  const password2 = await ask2("password", options.password ?? process.env.KROMA_PASSWORD, true);
+  const res = await fetch(`${url}/api/auth/login`, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({ email, password: password2 })
+  });
+  if (!res.ok)
+    throw new Error(`login failed (${res.status}): ${(await res.text()).trim()}`);
+  const { token, user } = Login.parse(await res.json());
+  const config = readConfig();
+  config.servers[url] = { token, user: user?.email ?? user?.name ?? email };
+  config.defaultServer = url;
+  writeConfig(config);
+  p2.outro(`signed in; token kept in ${configPath()}`);
+  return 0;
+}
+var Login;
+var init_login = __esm(() => {
+  init_config();
+  init_server();
+  Login = z8.object({
+    token: z8.string(),
+    user: z8.object({ email: z8.string().optional(), name: z8.string().optional() }).loose().optional()
+  });
+});
+
+// src/commands/plan.ts
+var exports_plan = {};
+__export(exports_plan, {
+  planCommand: () => planCommand
+});
+import { relative as relative6 } from "path";
+function planCommand(dirs, target, cwd = process.cwd()) {
+  const projects = findProjects(dirs, cwd);
+  const dir = targetDir(cwd, projects);
+  const triple = target?.trim() || process.env.KMOD_TARGET?.trim() || null;
+  const lines = [`export CARGO_TARGET_DIR="$PWD/${relative6(cwd, dir)}"`];
+  for (const project of projects) {
+    const server = project.server;
+    if (!server?.bin)
+      continue;
+    const { args } = cargoBuild(server.bin, server.features, triple, "release-kmod", dir);
+    const manifest = relative6(cwd, `${server.dir}/Cargo.toml`);
+    lines.push(`cargo ${args.join(" ")} --manifest-path ${manifest}`);
+  }
+  process.stdout.write(`${lines.join(`
+`)}
+`);
+  return 0;
+}
+var init_plan2 = __esm(() => {
+  init_cargo();
+  init_project();
+});
+
+// src/commands/cargo.ts
+var exports_cargo = {};
+__export(exports_cargo, {
+  cargoCommand: () => cargoCommand
+});
+import { existsSync as existsSync10 } from "fs";
+import { join as join14 } from "path";
+async function cargoCommand(args, cwd = process.cwd()) {
+  if (args.length === 0)
+    throw new Error("usage: kroma cargo <cargo-subcommand> [args...]");
+  const projects = findProjects([], cwd);
+  const dir = targetDir(cwd, projects);
+  const workspaces = projects.flatMap((p3) => p3.server ? [[p3.manifest.id, p3.server.dir]] : []);
+  const lib = join14(cwd, "modules", "lib");
+  if (existsSync10(join14(lib, "Cargo.toml")))
+    workspaces.push(["lib", lib]);
+  const failed = [];
+  for (const [id, crateDir] of workspaces) {
+    console.log(`
+=== ${id}: cargo ${args.join(" ")}`);
+    if (await cargo(crateDir, args, dir) !== 0)
+      failed.push(id);
+  }
+  if (failed.length > 0) {
+    console.error(`
+cargo ${args[0]} failed in ${failed.length} module(s): ${failed.join(", ")}`);
+    return 1;
+  }
+  console.log(`
+cargo ${args[0]}: every module passed`);
+  return 0;
+}
+var init_cargo2 = __esm(() => {
+  init_cargo();
+  init_project();
+});
+
+// src/bundle/read.ts
+import { createHash } from "crypto";
+import { existsSync as existsSync11, readdirSync as readdirSync7, readFileSync as readFileSync9 } from "fs";
+import { join as join15 } from "path";
+function iconDataUri(tar) {
+  const svg = tarRead(tar, "icon.svg");
+  if (svg && svg.length <= ICON_MAX) {
+    return `data:image/svg+xml;base64,${Buffer.from(svg).toString("base64")}`;
+  }
+  const png = tarRead(tar, "icon.png");
+  if (png && png.length <= ICON_MAX) {
+    return `data:image/png;base64,${Buffer.from(png).toString("base64")}`;
+  }
+  return;
+}
+function readBundle(path) {
+  const file = path.split("/").pop() ?? path;
+  const bytes = readFileSync9(path);
+  const tar = toTar(new Uint8Array(bytes.buffer, bytes.byteOffset, bytes.byteLength));
+  const manifestBytes = tarRead(tar, "module.json");
+  if (!manifestBytes) {
+    console.warn(`  ! ${file}: no module.json inside, skipped`);
+    return null;
+  }
+  const read = Manifest.safeParse(JSON.parse(new TextDecoder().decode(manifestBytes)));
+  if (!read.success) {
+    console.warn(`  ! ${file}: module.json is not a manifest, skipped (${read.error.message})`);
+    return null;
+  }
+  const manifest = read.data;
+  if (!speaksCurrentSchema(manifest)) {
+    console.warn(`  ! ${file}: built for manifest schema v${manifest.schemaVersion ?? 0}, and this SDK speaks v${MODULE_SCHEMA_VERSION}; skipped`);
+    return null;
+  }
+  const stem = file.slice(0, -".kmod".length);
+  const target = stem === manifest.id ? null : stem.slice(manifest.id.length).replace(/^-/, "") || null;
+  return {
+    manifest,
+    target,
+    file,
+    path,
+    size: bytes.length,
+    sha256: createHash("sha256").update(bytes).digest("hex"),
+    contentHash: createHash("sha256").update(tar).digest("hex"),
+    icon: iconDataUri(tar)
+  };
+}
+function readBundles(dir) {
+  if (!existsSync11(dir)) {
+    throw new Error(`no packed modules at ${dir}; run \`kroma build\` first`);
+  }
+  return readdirSync7(dir).filter((f) => f.endsWith(".kmod")).sort(byCodeUnit2).flatMap((f) => readBundle(join15(dir, f)) ?? []);
+}
+function toEntries(bundles, baseFor) {
+  const entries = new Map;
+  for (const b of bundles) {
+    const base = baseFor(b).replace(/\/$/, "");
+    const artifact = {
+      target: b.target,
+      file: b.file,
+      url: base ? `${base}/${b.file}` : b.file,
+      size: b.size,
+      sha256: b.sha256,
+      contentHash: b.contentHash
+    };
+    const existing = entries.get(b.manifest.id);
+    if (existing) {
+      existing.artifacts.push(artifact);
+      existing.icon ??= b.icon;
+      continue;
+    }
+    entries.set(b.manifest.id, {
+      ...b.manifest,
+      icon: b.icon,
+      artifacts: [artifact],
+      file: artifact.file,
+      url: artifact.url,
+      size: artifact.size,
+      sha256: artifact.sha256
+    });
+  }
+  const out = [...entries.values()].sort((a, b) => byCodeUnit2(a.id, b.id));
+  for (const m of out) {
+    m.artifacts.sort((a, b) => byCodeUnit2(a.target ?? "", b.target ?? ""));
+    const first = m.artifacts[0];
+    if (first) {
+      m.file = first.file;
+      m.url = first.url;
+      m.size = first.size;
+      m.sha256 = first.sha256;
+    }
+  }
+  return out;
+}
+var ICON_MAX;
+var init_read = __esm(() => {
+  init_src();
+  init_tar();
+  ICON_MAX = 64 * 1024;
+});
+
+// src/commands/registry.ts
+var exports_registry = {};
+__export(exports_registry, {
+  registryCommand: () => registryCommand,
+  resolveDir: () => resolveDir
+});
+import { copyFileSync as copyFileSync2, mkdirSync as mkdirSync5, writeFileSync as writeFileSync5 } from "fs";
+import { isAbsolute as isAbsolute2, join as join16 } from "path";
+function resolveDir(value, fallback, cwd) {
+  if (!value)
+    return join16(cwd, fallback);
+  return isAbsolute2(value) ? value : join16(cwd, value);
+}
+function registryCommand(options) {
+  const cwd = options.cwd ?? process.cwd();
+  const modulesDir = resolveDir(options.from, "dist/modules", cwd);
+  const outDir = resolveDir(options.out, "dist/registry", cwd);
+  const baseUrl = (options.base ?? "").replace(/\/$/, "");
+  const bundles = readBundles(modulesDir);
+  mkdirSync5(outDir, { recursive: true });
+  for (const b of bundles)
+    copyFileSync2(b.path, join16(outDir, b.file));
+  const modules = toEntries(bundles, () => baseUrl);
+  const write2 = (rel, value) => {
+    const path = join16(outDir, rel);
+    mkdirSync5(join16(path, ".."), { recursive: true });
+    writeFileSync5(path, `${JSON.stringify(value, null, 2)}
+`);
+  };
+  write2("catalog.json", { schema: 2, generatedAt: new Date().toISOString(), modules });
+  write2("registry.json", buildDescriptor("KROMA modules", baseUrl, modules));
+  write2("index.json", buildIndex(modules));
+  for (const entry of modules)
+    write2(`m/${entry.id}.json`, buildModuleRecord(entry));
+  for (const name of SCHEMA_NAMES) {
+    const schema = jsonSchema(name);
+    write2(schemaPath(name).replace(/^\//, ""), schema);
+    write2(`schemas/${name}.json`, schema);
+  }
+  console.log(`registry: ${modules.length} module(s) -> ${outDir}`);
+  for (const m of modules) {
+    const targets = m.artifacts.map((a) => a.target ?? "universal").join(", ");
+    console.log(`  ${m.id}  v${m.version}  [${targets}]`);
+  }
+  return 0;
+}
+var init_registry = __esm(() => {
+  init_src();
+  init_read();
+});
+
+// src/commands/serve.ts
+var exports_serve = {};
+__export(exports_serve, {
+  registryApp: () => registryApp,
+  serveCommand: () => serveCommand
+});
+import { existsSync as existsSync12, readFileSync as readFileSync10 } from "fs";
+import { join as join17 } from "path";
+import { Hono } from "hono";
+function registryApp(dir) {
+  const app = new Hono;
+  const entries = (url) => toEntries(readBundles(dir), () => origin(url));
+  app.get("/registry.json", (c) => json(buildDescriptor(REGISTRY_NAME, origin(c.req.url), entries(c.req.url))));
+  app.get("/index.json", (c) => json(buildIndex(entries(c.req.url))));
+  app.get("/m/:id{[^/]+[.]json}", (c) => {
+    const id = decodeURIComponent(c.req.param("id").replace(/\.json$/, ""));
+    const found = entries(c.req.url).find((m) => m.id === id);
+    return found ? json(buildModuleRecord(found)) : c.json({ error: "no such module" }, 404);
+  });
+  app.get("/schemas/:version{[0-9]+}/:name{[^/]+[.]json}", (c) => {
+    const name = schemaNamed(c.req.param("name"));
+    if (!name)
+      return c.json({ error: "no such schema" }, 404);
+    return json(jsonSchema(name, Number(c.req.param("version"))));
+  });
+  app.get("/schemas/:name{[^/]+[.]json}", (c) => {
+    const name = schemaNamed(c.req.param("name"));
+    return name ? json(jsonSchema(name)) : c.json({ error: "no such schema" }, 404);
+  });
+  app.get("/:file{[^/]+[.]kmod}", (c) => {
+    const file = c.req.param("file");
+    const named = readBundles(dir).some((b) => b.file === file);
+    const path = join17(dir, file);
+    if (!named || !existsSync12(path))
+      return c.json({ error: "no such bundle" }, 404);
+    const bytes = readFileSync10(path);
+    return new Response(new Uint8Array(bytes.buffer, bytes.byteOffset, bytes.byteLength), {
+      headers: { "content-type": "application/octet-stream" }
+    });
+  });
+  return app;
+}
+async function serveCommand(options) {
+  const cwd = options.cwd ?? process.cwd();
+  const dir = resolveDir(options.from, "dist/modules", cwd);
+  const port = options.port ?? 4173;
+  Bun.serve({ port, fetch: registryApp(dir).fetch });
+  const found = readBundles(dir);
+  console.log(`serving ${found.length} bundle(s) from ${dir}
+`);
+  for (const b of found)
+    console.log(`  ${b.manifest.id}  v${b.manifest.version}`);
+  console.log(`
+  http://localhost:${port}/registry.json`);
+  console.log(`
+Add http://localhost:${port} under Admin -> Modules -> Registries to browse it.`);
+  await new Promise(() => {});
+  return 0;
+}
+var REGISTRY_NAME = "KROMA modules (local)", origin = (url) => new URL(url).origin, json = (value) => new Response(`${JSON.stringify(value, null, 2)}
+`, {
+  headers: { "content-type": "application/json", "access-control-allow-origin": "*" }
+}), schemaNamed = (name) => SCHEMA_NAMES.find((candidate) => candidate === name.replace(/\.json$/, ""));
+var init_serve = __esm(() => {
+  init_src();
+  init_read();
+  init_registry();
+});
+
+// src/bundle/catalog.ts
+import { z as z9 } from "zod";
+var Artifact, Entry, Catalog;
+var init_catalog = __esm(() => {
+  init_src();
+  Artifact = ArtifactRef.extend({
+    target: z9.string().nullable(),
+    file: z9.string(),
+    size: z9.number().int().nonnegative(),
+    sha256: z9.string(),
+    contentHash: z9.string()
+  });
+  Entry = DescribedModule.extend({
+    icon: z9.string().optional(),
+    artifacts: z9.array(Artifact),
+    file: z9.string(),
+    url: z9.string(),
+    size: z9.number().int().nonnegative(),
+    sha256: z9.string()
+  });
+  Catalog = z9.object({
+    schema: z9.number(),
+    generatedAt: z9.string().nullish(),
+    modules: z9.array(Entry).default([])
+  });
+});
+
+// src/commands/release.ts
+var exports_release = {};
+__export(exports_release, {
+  decide: () => decide,
+  releaseCommand: () => releaseCommand,
+  tagFor: () => tagFor,
+  verdictFor: () => verdictFor
+});
+import { existsSync as existsSync13, mkdirSync as mkdirSync6, readFileSync as readFileSync11, writeFileSync as writeFileSync6 } from "fs";
+import { join as join18 } from "path";
+function tagFor(id, version) {
+  return `${id}@${version}`;
+}
+function verdictFor(local, live) {
+  if (!live)
+    return { kind: "new" };
+  const order = compareRaw(local.version, live.version);
+  if (order < 0)
+    return { kind: "backwards", published: live.version };
+  if (order > 0)
+    return { kind: "publish", from: live.version };
+  const liveHashes = new Map(live.artifacts.map((a) => [a.target ?? "", a.contentHash]));
+  const stale = local.artifacts.filter((a) => {
+    const published = liveHashes.get(a.target ?? "");
+    return published !== undefined && published !== a.contentHash;
+  }).map((a) => a.target ?? "universal");
+  stale.sort(byCodeUnit2);
+  if (stale.length > 0) {
+    return { kind: "stale", published: live.version, targets: stale };
+  }
+  return { kind: "unchanged" };
+}
+async function loadPublished(source) {
+  if (!/^https?:\/\//.test(source)) {
+    if (!existsSync13(source))
+      throw new Error(`--published ${source} does not exist`);
+    return Catalog.parse(JSON.parse(readFileSync11(source, "utf8")));
+  }
+  const res = await fetch(source, { headers: { "user-agent": "kroma-cli" } });
+  if (res.status === 404) {
+    console.warn(`  ! ${source} is 404: treating every module as a first release`);
+    return { schema: 2, modules: [] };
+  }
+  if (!res.ok)
+    throw new Error(`${source}: HTTP ${res.status}`);
+  return Catalog.parse(await res.json());
+}
+function decide(bundles, published, repo, now) {
+  const live = new Map((published.modules ?? []).map((m) => [m.id, m]));
+  const local = toEntries(bundles, (b) => `https://github.com/${repo}/releases/download/${tagFor(b.manifest.id, b.manifest.version)}`);
+  const plan = { publish: [], unchanged: [], carried: [] };
+  const stale = [];
+  const errors = [];
+  const entries = [];
+  for (const entry of local) {
+    if (!parse(entry.version)) {
+      errors.push(`${entry.id}: version ${JSON.stringify(entry.version)} is not semver, so it cannot be ordered against what is published`);
+      continue;
+    }
+    const verdict = verdictFor(entry, live.get(entry.id));
+    switch (verdict.kind) {
+      case "new":
+      case "publish":
+        plan.publish.push({
+          id: entry.id,
+          version: entry.version,
+          tag: tagFor(entry.id, entry.version),
+          files: entry.artifacts.flatMap((a) => [a.file, `${a.file}.sha256`]),
+          reason: verdict.kind
+        });
+        entries.push(entry);
+        break;
+      case "unchanged":
+        plan.unchanged.push(entry.id);
+        entries.push(live.get(entry.id));
+        break;
+      case "stale":
+        stale.push([
+          `${entry.id}: the bundle changed but the version did not.`,
+          `    module.json says ${entry.version}, which is already published`,
+          `    differing target(s): ${verdict.targets.join(", ")}`,
+          `    Bump the module's version past ${verdict.published} and re-push.`
+        ].join(`
+`));
+        entries.push(live.get(entry.id));
+        break;
+      case "backwards":
+        errors.push(`${entry.id}: version ${entry.version} is OLDER than the published ${verdict.published}; a release cannot go backwards`);
+        entries.push(live.get(entry.id));
+        break;
+    }
+  }
+  const packed = new Set(local.map((m) => m.id));
+  for (const [id, entry] of live) {
+    if (!packed.has(id)) {
+      plan.carried.push(id);
+      entries.push(entry);
+    }
+  }
+  entries.sort((a, b) => byCodeUnit2(a.id, b.id));
+  return { plan, catalog: { schema: 2, generatedAt: now, modules: entries }, stale, errors };
+}
+function report(plan, stale, errors, strict) {
+  for (const r of plan.publish) {
+    const label = r.reason === "new" ? "new" : "update";
+    console.log(`  publish  ${r.tag}  (${label}, ${r.files.length / 2} artifact(s))`);
+  }
+  for (const id of plan.unchanged)
+    console.log(`  unchanged ${id}`);
+  for (const id of plan.carried)
+    console.log(`  carried  ${id} (not built in this run)`);
+  if (stale.length > 0) {
+    console.warn(`
+${stale.length} module(s) changed without a version bump, NOT published:
+`);
+    for (const s of stale)
+      console.warn(`  ! ${s}
+`);
+    console.warn(strict ? "  --strict: treating unbumped modules as a failure." : "  The ready modules above still ship. Bump these and re-push to release them.");
+  }
+  if (errors.length > 0) {
+    console.error(`
+${errors.length} module(s) cannot be released:
+`);
+    for (const e of errors)
+      console.error(`  x ${e}
+`);
+  }
+}
+async function releaseCommand(options) {
+  const repo = options.repo ?? process.env.GITHUB_REPOSITORY;
+  if (!repo)
+    throw new Error("--repo owner/name is required (or set GITHUB_REPOSITORY)");
+  const cwd = options.cwd ?? process.cwd();
+  const modulesDir = resolveDir(options.from, "dist/modules", cwd);
+  const outDir = resolveDir(options.out, "dist/registry", cwd);
+  const bundles = readBundles(modulesDir);
+  const published = await loadPublished(options.published ?? DEFAULT_REGISTRY);
+  const { plan, catalog, stale, errors } = decide(bundles, published, repo, new Date().toISOString());
+  report(plan, stale, errors, options.strict === true);
+  if (errors.length > 0)
+    return 1;
+  if (options.strict && stale.length > 0)
+    return 1;
+  if (options.dryRun) {
+    console.log(`
+--dry-run: wrote nothing`);
+    return 0;
+  }
+  mkdirSync6(outDir, { recursive: true });
+  writeFileSync6(join18(outDir, "modules.json"), `${JSON.stringify(catalog, null, 2)}
+`);
+  writeFileSync6(join18(outDir, "plan.json"), `${JSON.stringify(plan, null, 2)}
+`);
+  console.log(`
+${plan.publish.length} release(s) to cut; catalog describes ${catalog.modules.length} module(s) -> ${outDir}`);
+  return 0;
+}
+var DEFAULT_REGISTRY = "https://modules.kroma.tv/modules.json";
+var init_release = __esm(() => {
+  init_src();
+  init_catalog();
+  init_read();
+  init_registry();
+});
+
+// src/cli.ts
+import { defineCommand, runMain } from "citty";
+
+// src/exit-after.ts
+async function exitAfter(work) {
+  try {
+    return process.exit(await work);
+  } catch (error) {
+    console.error(error instanceof Error ? error.message : String(error));
+    return process.exit(1);
+  }
+}
+
+// src/cli.ts
+var dirsArg = {
+  type: "positional",
+  required: false,
+  description: "Module directories; default: this module, or every one under modules/"
+};
+var serverArgs = {
+  server: { type: "string", valueHint: "url", description: "The KROMA server (KROMA_SERVER)" },
+  token: { type: "string", valueHint: "token", description: "A session token (KROMA_TOKEN)" }
+};
+var text3 = (v) => typeof v === "string" && v !== "" ? v : undefined;
+var list = (v) => {
+  if (Array.isArray(v))
+    return v.map(String);
+  return typeof v === "string" && v !== "" ? [v] : [];
+};
+var create = defineCommand({
+  meta: {
+    name: "create",
+    description: "Scaffold a module: a few questions, then a project ready for `kroma dev`."
+  },
+  args: {
+    dir: {
+      type: "positional",
+      required: false,
+      description: "Where to put it (defaults to the module id)"
+    },
+    id: { type: "string", valueHint: "tv.acme.notes", description: "The module id" },
+    name: { type: "string", description: "Display name" },
+    description: { type: "string", description: "One line about the module" },
+    kind: {
+      type: "string",
+      valueHint: "full|server|ui",
+      description: "A page and a sidecar, a sidecar, or a page"
+    },
+    storage: { type: "boolean", description: "The sidecar keeps its own database" },
+    "in-repo": {
+      type: "boolean",
+      description: "Path deps into this checkout (the default inside it)"
+    },
+    install: {
+      type: "boolean",
+      default: true,
+      description: "Run bun install afterwards",
+      negativeDescription: "Skip bun install"
+    },
+    yes: { type: "boolean", default: false, description: "Take every default, ask nothing" }
+  },
+  run: ({ args }) => exitAfter(Promise.resolve().then(() => (init_create(), exports_create)).then((m) => m.createCommand({
+    dir: text3(args.dir),
+    id: text3(args.id),
+    name: text3(args.name),
+    description: text3(args.description),
+    kind: text3(args.kind),
+    storage: typeof args.storage === "boolean" ? args.storage : undefined,
+    inRepo: typeof args["in-repo"] === "boolean" ? args["in-repo"] : undefined,
+    install: args.install !== false,
+    yes: args.yes === true
+  })))
+});
+var dev = defineCommand({
+  meta: {
+    name: "dev",
+    description: "Build the module, install it on a server, and again on every save."
+  },
+  args: {
+    dir: {
+      type: "positional",
+      required: false,
+      description: "The module directory (default: here)"
+    },
+    target: {
+      type: "string",
+      valueHint: "triple",
+      description: "Cross-compile the sidecar for the server"
+    },
+    ...serverArgs
+  },
+  run: ({ args }) => exitAfter(Promise.resolve().then(() => (init_dev(), exports_dev)).then((m) => m.devCommand({
+    dir: text3(args.dir),
+    target: text3(args.target),
+    server: text3(args.server),
+    token: text3(args.token)
+  })))
+});
+var build2 = defineCommand({
+  meta: {
+    name: "build",
+    description: "Pack the installable .kmod: the sidecar, the frontend, the manifest."
+  },
+  args: {
+    dirs: dirsArg,
+    out: {
+      type: "string",
+      valueHint: "dir",
+      description: "Output directory (default: dist/modules)"
+    },
+    target: {
+      type: "string",
+      valueHint: "triple",
+      description: "Cross-compile for this Rust target (KMOD_TARGET)"
+    },
+    debug: { type: "boolean", default: false, description: "A dev-profile sidecar" },
+    "skip-build": {
+      type: "boolean",
+      default: false,
+      description: "Pack a binary built out of band (KMOD_SKIP_BUILD)"
+    }
+  },
+  run: ({ args }) => exitAfter(Promise.resolve().then(() => (init_build3(), exports_build)).then((m) => m.buildCommand({
+    dirs: list(args._),
+    out: text3(args.out),
+    target: text3(args.target),
+    profile: args.debug ? "dev" : "release-kmod",
+    skipBuild: args["skip-build"] || undefined
+  })))
+});
+var check = defineCommand({
+  meta: {
+    name: "check",
+    description: "Validate the manifest, type-check the frontend, clippy the sidecar."
+  },
+  args: {
+    dirs: dirsArg,
+    rust: {
+      type: "boolean",
+      default: true,
+      description: "Run clippy",
+      negativeDescription: "Skip clippy"
+    },
+    ts: { type: "boolean", default: true, description: "Run tsc", negativeDescription: "Skip tsc" }
+  },
+  run: ({ args }) => exitAfter(Promise.resolve().then(() => (init_check(), exports_check)).then((m) => m.checkCommand({ dirs: list(args._), rust: args.rust !== false, ts: args.ts !== false })))
+});
+var install = defineCommand({
+  meta: { name: "install", description: "Upload a packed .kmod to a running server." },
+  args: {
+    id: {
+      type: "positional",
+      required: false,
+      description: "The module id (default: this module)"
+    },
+    file: { type: "string", valueHint: "path", description: "A .kmod to upload instead" },
+    from: {
+      type: "string",
+      valueHint: "dir",
+      description: "Where the bundles are (default: dist/modules)"
+    },
+    ...serverArgs
+  },
+  run: ({ args }) => exitAfter(Promise.resolve().then(() => (init_install(), exports_install)).then((m) => m.installCommand({
+    id: text3(args.id),
+    file: text3(args.file),
+    from: text3(args.from),
+    server: text3(args.server),
+    token: text3(args.token)
+  })))
+});
+var login = defineCommand({
+  meta: { name: "login", description: "Sign in to a server once; dev and install use the token." },
+  args: {
+    server: {
+      type: "positional",
+      required: false,
+      description: "The server URL (default: http://localhost:4040)"
+    },
+    email: { type: "string", description: "Email or username (KROMA_EMAIL)" },
+    password: { type: "string", description: "Password (KROMA_PASSWORD)" }
+  },
+  run: ({ args }) => exitAfter(Promise.resolve().then(() => (init_login(), exports_login)).then((m) => m.loginCommand({
+    server: text3(args.server),
+    email: text3(args.email),
+    password: text3(args.password)
+  })))
+});
+var plan = defineCommand({
+  meta: {
+    name: "plan",
+    description: "Print the cargo build lines CI runs in its cross-compile container."
+  },
+  args: {
+    dirs: dirsArg,
+    target: { type: "string", valueHint: "triple", description: "The Rust target (KMOD_TARGET)" }
+  },
+  run: ({ args }) => exitAfter(Promise.resolve().then(() => (init_plan2(), exports_plan)).then((m) => m.planCommand(list(args._), text3(args.target))))
+});
+var cargo2 = defineCommand({
+  meta: { name: "cargo", description: "Run one cargo subcommand in every module workspace." },
+  args: {
+    args: {
+      type: "positional",
+      required: true,
+      description: "The cargo subcommand and its arguments"
+    }
+  },
+  run: ({ rawArgs }) => exitAfter(Promise.resolve().then(() => (init_cargo2(), exports_cargo)).then((m) => m.cargoCommand(rawArgs.filter((a) => a !== "--"))))
+});
+var registry = defineCommand({
+  meta: {
+    name: "registry",
+    description: "Write the packed bundles as a static registry for any host."
+  },
+  args: {
+    from: {
+      type: "string",
+      valueHint: "dir",
+      description: "Where the bundles are (default: dist/modules)"
+    },
+    out: {
+      type: "string",
+      valueHint: "dir",
+      description: "Output directory (default: dist/registry)"
+    },
+    base: {
+      type: "string",
+      valueHint: "url",
+      description: "The URL the registry will be served at"
+    }
+  },
+  run: ({ args }) => exitAfter(Promise.resolve().then(() => (init_registry(), exports_registry)).then((m) => m.registryCommand({ from: text3(args.from), out: text3(args.out), base: text3(args.base) })))
+});
+var serve = defineCommand({
+  meta: { name: "serve", description: "Serve the packed bundles as a live registry to browse." },
+  args: {
+    from: {
+      type: "string",
+      valueHint: "dir",
+      description: "Where the bundles are (default: dist/modules)"
+    },
+    port: { type: "string", valueHint: "port", description: "Port (default: 4173)" }
+  },
+  run: ({ args }) => exitAfter(Promise.resolve().then(() => (init_serve(), exports_serve)).then((m) => m.serveCommand({ from: text3(args.from), port: args.port ? Number(args.port) : undefined })))
+});
+var release = defineCommand({
+  meta: { name: "release", description: "Decide which packed modules publish on their own tags." },
+  args: {
+    repo: {
+      type: "string",
+      valueHint: "owner/name",
+      description: "The GitHub repository (GITHUB_REPOSITORY)"
+    },
+    published: {
+      type: "string",
+      valueHint: "url|file",
+      description: "The live catalog to compare against"
+    },
+    from: {
+      type: "string",
+      valueHint: "dir",
+      description: "Where the bundles are (default: dist/modules)"
+    },
+    out: {
+      type: "string",
+      valueHint: "dir",
+      description: "Output directory (default: dist/registry)"
+    },
+    "dry-run": { type: "boolean", default: false, description: "Decide and print, write nothing" },
+    strict: {
+      type: "boolean",
+      default: false,
+      description: "An unbumped changed module fails the run"
+    }
+  },
+  run: ({ args }) => exitAfter(Promise.resolve().then(() => (init_release(), exports_release)).then((m) => m.releaseCommand({
+    repo: text3(args.repo),
+    published: text3(args.published),
+    from: text3(args.from),
+    out: text3(args.out),
+    dryRun: args["dry-run"] === true,
+    strict: args.strict === true
+  })))
+});
+var main = defineCommand({
+  meta: { name: "kroma", description: "Build KROMA modules." },
+  subCommands: { create, dev, build: build2, check, install, login, plan, cargo: cargo2, registry, serve, release }
+});
+runMain(main);