@omochi-ui/cli 0.1.1 → 0.2.0

package/README.md

@@ -1,279 +1,65 @@
-# CLI reference
+# Omochi native services
 
-[Overview](../../README.md) · [Architecture](../../docs/architecture.md) · [Discovery guide](../../docs/discovery.md)
+The archive contains omochi-ui and omochi-utils for the target in manifest.json.
+The production dashboard is embedded. Neither binary requires Bun, Node.js,
+Python or Rust at runtime. Applications launched by them need their own runtime.
 
-Build the workspace with `bun install` and `bun run build`. Run commands from its
-root using `bun run omochi-ui`; the binary is provided by `@omochi-ui/cli`; the TypeScript SDK is
-`@omochi-ui/sdk`.
+Verify the archive against its .sha256 file, extract it, and install both binaries:
 
-```sh
-bun run omochi-ui --help
-bun run omochi-ui hub --help
-bun run omochi-ui help generate catalog
-```
+    ./install.sh                       # $HOME/.local/bin
+    ./install.sh /your/preferred/bin   # optional destination
+    omochi-ui hub
 
-No arguments prints the overview. `-h`, `--help`, and `help <command>` print help
-to stdout and exit successfully without starting services or changing config.
-Invalid arguments print usage to stderr and exit with code 2.
+The default dashboard is http://127.0.0.1:5555. Keep this loopback default.
+Use omochi-ui up omochi.toml for compositions, and omochi-utils --help for utility
+modes. dev bridges application stdio to the separate developer preview frontend;
+the Vite developer preview is not included in this archive.
 
-## Command map
+## Pairing
 
-| Task | Command | Browser UI included? |
-| --- | --- | --- |
-| Start a project composition | `up [FILE]` | Yes; `--open` opens it automatically |
-| Develop a single app | `dev -- <command> [args...]` | Start the Vite preview separately |
-| Compose dashboards from running apps | `hub` | Yes |
-| Publish this machine's running apps | `gateway` | No; connect a hub |
-| Show or name this machine | `id` | No |
-| Pair with a TCP gateway | `pair HOST:PORT` | No |
-| Inspect or remove paired peers | `trust list`, `trust forget <nodeId>` | No |
-| Generate SDK catalog types | `generate catalog` | No |
+On the gateway machine:
 
-## up
+    omochi-ui gateway --remote --pair --name workstation
 
-Start local services, the hub, and a read-only dashboard preset from TOML.
+Import its invitation on the hub PC:
 
-```sh
-bun run omochi-ui up --open
-bun run omochi-ui up --port 5557 ./examples/quickstart/omochi.toml
-```
+    omochi-ui pair --name workstation
+    # Paste the invitation on stdin, then Ctrl+D.
+    omochi-ui hub
 
-The file defaults to `./omochi.toml`. A service uses either a literal `command`
-or an `omochi-utils` shorthand. Commands do not use a shell; relative working
-directories are resolved from the composition file. Child services receive
-`OMOCHI_SERVICE` and remain independent: one exiting leaves its panel unavailable
-without stopping the others. Utility shorthand supports `button`, `watch`,
-`process`, `tail`, and `http`. Stdio-owned `stream` and `mcp` processes stay
-external; this lets an agent connect and disconnect independently of the preset.
+Possession of an invitation grants access. It expires after 180 seconds and admits
+one hub; keep it private. Registered gateways connect automatically without IP
+input. --offline disables public discovery and relays while retaining LAN mDNS
+and direct connections.
 
-```toml
-version = 1
-id = "local-development"
+Online development uses n0 public discovery and relays. For a project relay, use
+the same --relay https://your-relay.example option on remote gateway, pair and hub
+commands. This archive does not provision a relay. The source repository includes host
+configuration and monitoring templates in deploy/relay.
 
-[services.health]
-utility = ["http", "http://127.0.0.1:5173/"]
+status reports registered gateway connection attempts and failures from the running
+hub (use --port if the hub has a non-default port). It does not initialize state.
 
-[services.app]
-command = ["uv", "run", "app.py"]
-cwd = "./backend"
+trust list shows peers. trust forget NAME_OR_ENDPOINT_ID waits for live processes
+to destroy revoked connections. An acknowledgement failure remains an error even
+though the trust removal is already durable.
 
-[dashboard]
-name = "Local development"
+## Breaking upgrade
 
-[[dashboard.rows]]
-panels = ["health", "app"]
-height = "medium"
+Stop old gateways/hubs first. SDK APIs and manifests are unchanged; gateway wire
+protocol and NodeIds are new. Pair devices again and recreate saved dashboards.
+Native state lives at $XDG_CONFIG_HOME/omochi/rust-v1 or
+$HOME/.config/omochi/rust-v1. Legacy state is left untouched.
 
-[dashboard.panels.health]
-title = "Health"
-service = "health"
+Linux binaries use their build runner's libc; choose an OS/architecture-compatible
+archive and libc, or build from source. This script does not codesign or notarize
+macOS binaries.
 
-[dashboard.panels.app]
-title = "Application"
-service = "app"
-```
+## Registry distributions
 
-Rows divide the twelve-column dashboard evenly. Heights are `small`, `medium`,
-or `large`; a panel's surface defaults to `main`. Presets do not modify saved
-dashboard storage. Use **Save as dashboard** in the hub to make an editable copy.
-Ctrl+C stops only the services and gateway started by this command.
-
-| Option | Meaning | Default |
-| --- | --- | --- |
-| `--host HOST` | Hub bind address | `127.0.0.1` |
-| `--port PORT` | Hub port; `0` chooses an available port | `5555` |
-| `--allow-origin ORIGIN` | Add an exact browser origin; repeatable | Loopback origins only |
-| `--open` | Open the selected preset in the desktop browser | Off |
-
-## dev
-
-Launch a child application and bridge its JSONL stdin/stdout to WebSocket.
-
-```sh
-# Terminal 1: browser preview
-bun run --filter @omochi-ui/dev-server dev
-# Terminal 2: app + bridge
-bun run omochi-ui dev -- uv run --project examples/python examples/python/app.py
-```
-
-Open `http://127.0.0.1:5173/`. The preview's default `/ws` proxy reaches the bridge.
-All arguments after `--` belong to the child, including any `--help` flag.
-Application logging must go to stderr; stdout is reserved for A2UI JSONL.
-
-| Option | Meaning | Default |
-| --- | --- | --- |
-| `--host HOST` | Bridge bind address | `127.0.0.1` |
-| `--port PORT` | Bridge port; `0` chooses an available port | `5555` |
-
-The bridge serves WebSocket at `/ws`; it does not serve an HTML page. Startup
-prints a preview URL with `?ws=` for its actual address. The preview must already
-be running; use its printed port if Vite selected one other than 5173.
-All clients share application state, and late clients receive a current snapshot.
-The bridge has no authentication or TLS; keep the loopback default.
-
-## hub
-
-Serve the dashboard UI, discover available surfaces, and route browser actions.
-Apps must already be running with `UnixSocketServerTransport`. The bundled
-examples select that transport when `OMOCHI_SERVICE` is set.
-
-```sh
-# Terminal 1
-OMOCHI_SERVICE=python-example uv run --project examples/python examples/python/app.py
-# Terminal 2
-bun run omochi-ui hub
-```
-
-Open `http://127.0.0.1:5555/`. The hub serves its own UI and automatically starts
-a local gateway when none is listening. It reuses an existing gateway and does
-not stop a gateway it did not start.
-
-| Option | Meaning | Default |
-| --- | --- | --- |
-| `--host HOST` | HTTP/WebSocket bind address | `127.0.0.1` |
-| `--port PORT` | HTTP/WebSocket port; `0` chooses an available port | `5555` |
-| `--gateway TARGET` | Unix socket path or `<nodeId>@HOST:PORT`; repeatable | Local gateway |
-| `--ssh HOST` | SSH hostname, alias, or `user@host`; one target | Off |
-| `--ssh-socket PATH` | Remote gateway socket override; requires `--ssh` | Resolved through SSH |
-| `--no-auto-gateway` | Do not start a missing local gateway | Auto-start enabled |
-| `--discover-lan` | Also look for paired gateways via mDNS | Off |
-| `--allow-origin ORIGIN` | Add an exact allowed browser origin; repeatable | Loopback origins only |
-
-Explicit `--gateway` or `--ssh` targets replace the default local gateway. Add
-`--gateway /path/to/local/gateway.sock` to include it too. Explicit targets can
-be combined with `--discover-lan`. A TCP target needs its paired node ID; a Unix
-socket or SSH target does not need pairing.
-
-```sh
-# Remote machine: gateway and apps must already be running
-bun run omochi-ui gateway
-# Local machine: SSH authenticates and forwards the remote gateway socket
-bun run omochi-ui hub --ssh user@remote
-```
-
-The hub has no authentication or TLS on its browser-facing listener. Keep its
-loopback binding. See [SSH setup](../../docs/discovery.md#connecting-through-ssh)
-for requirements and cleanup behavior.
-
-## gateway
-
-Discover the current user's apps and publish their surfaces. A gateway does not
-launch apps or serve the dashboard UI. It normally listens only on a Unix socket.
-
-```sh
-bun run omochi-ui gateway
-```
-
-| Option | Meaning | Default |
-| --- | --- | --- |
-| `--root DIR` | Directory containing service manifests and sockets | `$XDG_RUNTIME_DIR/omochi` |
-| `--socket PATH` | Gateway Unix socket | `<root>/gateway.sock` |
-| `--node-name NAME` | Persist this machine's display name | Existing name or hostname |
-| `--listen HOST:PORT` | Enable the TLS TCP listener | Off |
-| `--advertise` | Advertise over mDNS; requires a TCP listener | Off |
-| `--pair` | Open a one-time pairing window; requires a TCP listener | Off |
-| `--lan` | `--listen 0.0.0.0:5556 --advertise` | Off |
-
-If `XDG_RUNTIME_DIR` is unset, the registry uses
-`<system temporary directory>/omochi-<uid>/omochi`. Apps and gateways must use the
-same runtime directory. See [Service discovery](../../docs/discovery.md) for the
-manifest format and SDK transport examples.
-
-Network reachability, advertisement, and trust are separate. `--listen` enables
-the paired TLS listener; mDNS only advertises its location. Neither allows an
-unpaired hub to read application data.
-
-## pair
-
-Pair once before connecting a hub to a gateway over TCP. SSH does not require this.
-
-```sh
-# Machine running the apps: open a TCP listener and pairing window
-bun run omochi-ui gateway --lan --pair
-# Machine running the hub: enter the code printed by the gateway
-bun run omochi-ui pair 192.168.1.42:42317  # use the random pairing port printed above
-```
-
-`pair HOST:PORT` reads the code from stdin. `--code CODE` supplies it explicitly;
-stdin keeps it out of shell history. The window lasts three minutes, permits
-five exchange attempts, and closes after one successful pairing. Its dedicated HTTPS
-listener uses a random port and exposes no application API. Normal connections use
-mutual TLS with pinned device certificates; legacy PSK peers must pair again.
-
-After success, run the printed `hub --gateway <nodeId>@HOST:PORT` command, prefixed
-with `bun run` in a source checkout. Alternatively, use `hub --discover-lan`
-when the gateway advertises on the same local network. mDNS generally does not
-cross VLANs or VPNs.
-
-## id and trust
-
-```sh
-bun run omochi-ui id
-bun run omochi-ui id --node-name workstation
-bun run omochi-ui trust list
-bun run omochi-ui trust forget NODE_ID
-```
-
-`id` creates a persistent identity on first use and prints its node ID and name.
-Changing the name preserves the ID. `trust list` prints peer IDs, roles, names,
-and pairing times. `trust forget` removes the local peer entry and waits for running local processes
-to close affected connections before reporting success; it returns code
-1 when the peer does not exist. Pair again to establish trust after removal.
-
-## generate catalog
-
-Generate typed bindings from a local A2UI v0.9 catalog for any subset of SDKs.
-Create output directories before running the command.
-
-```sh
-mkdir -p generated
-bun run omochi-ui generate catalog \
-  --catalog ./catalog.json \
-  --name ProductCatalog \
-  --typescript ./generated/product-catalog.ts \
-  --python ./generated/product_catalog.py \
-  --rust ./generated/product_catalog.rs
-```
-
-| Option | Meaning |
-| --- | --- |
-| `--catalog FILE` | Required catalog JSON input |
-| `--name NAME` | Type name; defaults to catalog title or `GeneratedCatalog` |
-| `--typescript FILE` | TypeScript output |
-| `--python FILE` | Python output |
-| `--rust FILE` | Rust output |
-| `--check` | Check outputs without writing; fail if missing or stale |
-
-At least one output flag is required. Generation resolves local schemas only;
-it does not fetch schemas over the network. Reuse the same invocation with
-`--check` in CI.
-
-## Ports and storage
-
-| Resource | Default |
-| --- | --- |
-| Vite browser preview | `http://127.0.0.1:5173/` |
-| Development bridge | `ws://127.0.0.1:5555/ws` |
-| Hub UI / A2UI | `http://127.0.0.1:5555/` / `ws://127.0.0.1:5555/ws` |
-| Gateway Unix socket | `$XDG_RUNTIME_DIR/omochi/gateway.sock` (fallback above) |
-| Gateway TCP with `--lan` | `0.0.0.0:5556` (paired TLS) |
-| Node identity and peers | `$XDG_CONFIG_HOME/omochi/{node,peers}.json` |
-| Saved dashboards | `$XDG_CONFIG_HOME/omochi/dashboards.json` |
-
-`XDG_CONFIG_HOME` defaults to `~/.config`. Runtime directories and configuration
-are per-user; identity and trust persist across restarts. Dashboard files store
-names, surface references, and layouts, not app state.
-
-## Troubleshooting
-
-| Symptom | What to check |
-| --- | --- |
-| `dev` starts but there is no page | Start `bun run --filter @omochi-ui/dev-server dev` and open its URL, not port 5555 |
-| Preview says disconnected | Start the bridge; with a custom port, use the printed `?ws=` URL |
-| Address already in use | `dev` and `hub` share default port 5555; stop one or set `--port 5557` |
-| Vite uses a port other than 5173 | Use Vite's printed URL, adding the bridge's `?ws=` parameter if needed |
-| Hub has no apps | Run an app with `OMOCHI_SERVICE` set and the same user/runtime directory |
-| Hub loses the local apps when using SSH | Explicit targets replace the local default; add the local socket with `--gateway` |
-| Pairing/advertising requires a listener | Use `gateway --lan --pair` or provide `--listen HOST:PORT` |
-| Remote gateway is not found | Check that it is running; use SSH or an explicit paired TCP target when multicast is unavailable |
-| Command or build output is missing | Run `bun install` and `bun run build` from the repository root |
+Native releases also prepare npm `@omochi-ui/cli` and `@omochi-ui/utils` under
+the existing package names, using exact-version platform binary dependencies.
+The npm launcher needs Node.js 22+; the native archives above do not. Published
+Cargo sources can be installed with `cargo install omochi-cli --locked` and
+`cargo install omochi-utils --locked`. The existing `omochi-ui` crate remains the SDK.
+See docs/native-releasing.md in the repository for release setup and migration.

package/bin/omochi-ui.cjs

@@ -0,0 +1,34 @@
+#!/usr/bin/env node
+'use strict';
+const path = require('node:path');
+const { spawn } = require('node:child_process');
+const manifest = require('../package.json');
+const platform = `${process.platform}-${process.arch}`;
+const dependency = manifest.nativePlatforms[platform];
+function fail(message) { console.error(`[${manifest.name}] ${message}`); process.exit(1); }
+if (!dependency) fail(`Unsupported platform ${platform}. Use a supported Linux/glibc or macOS build.`);
+if (process.platform === 'linux' && !process.report?.getReport().header.glibcVersionRuntime) {
+  fail('The prebuilt Linux binary requires glibc. On musl, build with cargo install instead.');
+}
+let binary;
+try {
+  const installed = require.resolve(`${dependency}/package.json`);
+  const native = require(installed);
+  if (native.version !== manifest.version) fail(`Binary version mismatch: expected ${manifest.version}, found ${native.version}. Reinstall the package.`);
+  binary = path.join(path.dirname(installed), 'bin', manifest.nativeBinary);
+} catch {
+  fail(`Missing ${dependency}@${manifest.version}. Reinstall with optional dependencies enabled (npm install --include=optional).`);
+}
+const child = spawn(binary, process.argv.slice(2), { stdio: 'inherit' });
+const handlers = new Map();
+for (const signal of ['SIGINT', 'SIGTERM', 'SIGHUP']) {
+  const handler = () => child.kill(signal);
+  handlers.set(signal, handler);
+  process.on(signal, handler);
+}
+child.once('error', error => fail(`Cannot start ${binary}: ${error.message}`));
+child.once('exit', (code, signal) => {
+  for (const [name, handler] of handlers) process.removeListener(name, handler);
+  if (signal) process.kill(process.pid, signal);
+  else process.exitCode = code ?? 1;
+});

package/package.json

@@ -1,39 +1,35 @@
 {
   "name": "@omochi-ui/cli",
-  "publishConfig": {
-    "access": "public",
-    "registry": "https://registry.npmjs.org/"
-  },
+  "version": "0.2.0",
+  "description": "Native Omochi cli",
+  "files": [
+    "bin"
+  ],
   "engines": {
-    "bun": ">=1.4.3"
+    "node": ">=22"
   },
-  "version": "0.1.1",
-  "description": "CLI tools and stdio/WebSocket bridge for omochi-ui",
-  "license": "Apache-2.0",
-  "type": "module",
   "bin": {
-    "omochi-ui": "./bin/omochi-ui.js"
+    "omochi-ui": "./bin/omochi-ui.cjs"
   },
-  "files": [
-    "bin",
-    "dist"
-  ],
-  "dependencies": {
-    "@a2ui/web_core": "0.10.5",
-    "@omochi-ui/core": "0.1.1",
-    "@omochi-ui/discovery": "0.1.1",
-    "@omochi-ui/hub-ui": "0.1.1",
-    "@omochi-ui/utils": "0.1.1",
-    "smol-toml": "^1.9.0",
-    "ws": "^8.18.0"
+  "nativeBinary": "omochi-ui",
+  "nativePlatforms": {
+    "linux-x64": "@omochi-ui/native-linux-x64",
+    "linux-arm64": "@omochi-ui/native-linux-arm64",
+    "darwin-x64": "@omochi-ui/native-darwin-x64",
+    "darwin-arm64": "@omochi-ui/native-darwin-arm64"
+  },
+  "optionalDependencies": {
+    "@omochi-ui/native-linux-x64": "0.2.0",
+    "@omochi-ui/native-linux-arm64": "0.2.0",
+    "@omochi-ui/native-darwin-x64": "0.2.0",
+    "@omochi-ui/native-darwin-arm64": "0.2.0"
   },
+  "license": "Apache-2.0",
   "repository": {
     "type": "git",
-    "url": "https://github.com/k-kozika/omochi.git",
-    "directory": "packages/cli"
+    "url": "https://github.com/omochi-ui/omochi.git"
   },
-  "homepage": "https://github.com/k-kozika/omochi#readme",
-  "bugs": {
-    "url": "https://github.com/k-kozika/omochi/issues"
+  "publishConfig": {
+    "access": "public"
   }
 }

package/bin/omochi-ui.js

@@ -1,2 +0,0 @@
-#!/usr/bin/env bun
-import '../dist/cli.js'

package/dist/catalog-codegen.d.ts

@@ -1,9 +0,0 @@
-export interface GenerateCatalogOptions {
-    catalog: string;
-    name?: string;
-    typescript?: string;
-    python?: string;
-    rust?: string;
-    check?: boolean;
-}
-export declare function generateCatalog(options: GenerateCatalogOptions): Promise<void>;

package/dist/catalog-codegen.js

@@ -1,185 +0,0 @@
-import { createHash } from 'node:crypto';
-import { readFile, writeFile } from 'node:fs/promises';
-import { dirname, resolve } from 'node:path';
-const identifier = (value) => value.replace(/[^A-Za-z0-9]+(.)/g, (_, next) => next.toUpperCase()).replace(/^[^A-Za-z_]+/, '');
-const snake = (value) => value.replace(/([a-z0-9])([A-Z])/g, '$1_$2').replace(/[^A-Za-z0-9]+/g, '_').toLowerCase();
-function referenceType(ref, language) {
-    const name = ref.split('/').at(-1);
-    const maps = {
-        ts: { ComponentId: 'string', ChildList: 'string[] | { componentId: string; path: string }', DataBinding: 'DataBinding', FunctionCall: 'FunctionCall', DynamicValue: 'DynamicValue', DynamicString: 'DynamicString', DynamicNumber: 'DynamicNumber', DynamicBoolean: 'DynamicBoolean', DynamicStringList: 'DynamicStringList', AccessibilityAttributes: 'Accessibility', CheckRule: 'CheckRule', Action: 'WireAction' },
-        py: { ComponentId: 'str', ChildList: 'list[str] | dict[str, str]', DataBinding: 'DataBinding', FunctionCall: 'FunctionCall', DynamicValue: 'Any', DynamicString: 'DynamicString', DynamicNumber: 'DynamicNumber', DynamicBoolean: 'DynamicBoolean', DynamicStringList: 'DynamicStringList', AccessibilityAttributes: 'dict[str, DynamicString]', CheckRule: 'dict[str, Any]', Action: 'dict[str, Any]' },
-        rs: { ComponentId: 'String', ChildList: 'Value', DataBinding: 'Value', FunctionCall: 'Value', DynamicValue: 'Value', DynamicString: 'Value', DynamicNumber: 'Value', DynamicBoolean: 'Value', DynamicStringList: 'Value', AccessibilityAttributes: 'Value', CheckRule: 'Value', Action: 'Value' },
-    };
-    const value = maps[language][name];
-    if (!value)
-        throw new Error(`unsupported schema reference: ${ref}`);
-    return value;
-}
-function schemaType(schema, language) {
-    if (typeof schema.$ref === 'string')
-        return referenceType(schema.$ref, language);
-    if (Array.isArray(schema.allOf)) {
-        const values = schema.allOf.filter((item) => !item.if && !item.then).map((item) => schemaType(item, language));
-        if (values.length === 1)
-            return values[0];
-        return language === 'rs' ? 'Value' : values.join(' & ');
-    }
-    const union = (schema.anyOf ?? schema.oneOf);
-    if (union) {
-        const values = union.map((item) => schemaType(item, language));
-        return language === 'rs' ? 'Value' : values.join(' | ');
-    }
-    if (Array.isArray(schema.enum)) {
-        if (language === 'ts')
-            return schema.enum.map((value) => JSON.stringify(value)).join(' | ');
-        if (language === 'py')
-            return `Literal[${schema.enum.map((value) => JSON.stringify(value)).join(', ')}]`;
-        return 'String';
-    }
-    if (schema.type === 'string')
-        return language === 'ts' ? 'string' : language === 'py' ? 'str' : 'String';
-    if (schema.type === 'number' || schema.type === 'integer')
-        return language === 'ts' ? 'number' : language === 'py' ? 'float' : 'f64';
-    if (schema.type === 'boolean')
-        return language === 'ts' ? 'boolean' : language === 'py' ? 'bool' : 'bool';
-    if (schema.type === 'array') {
-        const item = schemaType(schema.items ?? {}, language);
-        return language === 'ts' ? `${item}[]` : language === 'py' ? `list[${item}]` : `Vec<${item}>`;
-    }
-    if (schema.type === 'object' && schema.properties) {
-        const entries = Object.entries(schema.properties);
-        if (language === 'ts')
-            return `{ ${entries.map(([key, value]) => `${JSON.stringify(key)}: ${schemaType(value, language)}`).join('; ')} }`;
-        return language === 'py' ? 'dict[str, Any]' : 'Value';
-    }
-    throw new Error(`unsupported schema fragment: ${JSON.stringify(schema)}`);
-}
-function pointer(document, fragment) {
-    if (!fragment || fragment === '#')
-        return document;
-    if (!fragment.startsWith('#/'))
-        throw new Error(`unsupported JSON Schema fragment: ${fragment}`);
-    return fragment.slice(2).split('/').reduce((value, part) => {
-        if (!value || typeof value !== 'object')
-            throw new Error(`unresolved JSON Schema fragment: ${fragment}`);
-        return value[part.replaceAll('~1', '/').replaceAll('~0', '~')];
-    }, document);
-}
-async function resolveLocalRefs(value, document, base, stack = new Set()) {
-    if (Array.isArray(value))
-        return Promise.all(value.map((item) => resolveLocalRefs(item, document, base, stack)));
-    if (!value || typeof value !== 'object')
-        return value;
-    const object = value;
-    if (typeof object.$ref === 'string' && !object.$ref.startsWith('http:') && !object.$ref.startsWith('https:')) {
-        const [filename, rawFragment = ''] = object.$ref.split('#', 2);
-        const fragment = `#${rawFragment}`;
-        const referenceKey = `${base}:${object.$ref}`;
-        if (stack.has(referenceKey))
-            throw new Error(`circular schema reference: ${object.$ref}`);
-        const nextStack = new Set(stack).add(referenceKey);
-        if (filename) {
-            const path = resolve(base, filename);
-            const external = JSON.parse(await readFile(path, 'utf8'));
-            const resolved = pointer(external, fragment);
-            return resolveLocalRefs({ ...resolved, ...Object.fromEntries(Object.entries(object).filter(([key]) => key !== '$ref')) }, external, dirname(path), nextStack);
-        }
-        const resolved = pointer(document, fragment);
-        return resolveLocalRefs({ ...resolved, ...Object.fromEntries(Object.entries(object).filter(([key]) => key !== '$ref')) }, document, base, nextStack);
-    }
-    return Object.fromEntries(await Promise.all(Object.entries(object).map(async ([key, item]) => [key, await resolveLocalRefs(item, document, base, stack)])));
-}
-function normalize(raw, requestedName, sourceHash) {
-    const catalog = JSON.parse(raw);
-    if (!catalog.components || typeof catalog.components !== 'object')
-        throw new Error('catalog must contain a components object');
-    const title = requestedName ?? (typeof catalog.title === 'string' ? catalog.title : 'GeneratedCatalog');
-    const name = identifier(title);
-    if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(name))
-        throw new Error(`catalog name is not a valid identifier: ${title}`);
-    const components = Object.entries(catalog.components).map(([componentName, schema]) => {
-        const layers = Array.isArray(schema.allOf) ? schema.allOf : [schema];
-        const properties = new Map();
-        const required = new Set();
-        for (const layer of layers) {
-            if (typeof layer.$ref === 'string') {
-                if (layer.$ref.endsWith('/ComponentCommon'))
-                    properties.set('accessibility', { $ref: 'https://a2ui.org/specification/v0_9/common_types.json#/$defs/AccessibilityAttributes' });
-                else if (layer.$ref.endsWith('/Checkable')) {
-                    properties.set('checks', { type: 'array', items: { $ref: 'https://a2ui.org/specification/v0_9/common_types.json#/$defs/CheckRule' } });
-                    properties.set('isValid', { type: 'boolean' });
-                    properties.set('validationErrors', { type: 'array', items: { type: 'string' } });
-                }
-                else if (layer.$ref === '#/$defs/CatalogComponentCommon')
-                    properties.set('weight', { type: 'number' });
-                else
-                    throw new Error(`unsupported component mixin: ${layer.$ref}`);
-            }
-            for (const [key, value] of Object.entries(layer.properties ?? {}))
-                if (key !== 'component' && key !== 'id')
-                    properties.set(key, value);
-            for (const key of layer.required ?? [])
-                if (key !== 'component' && key !== 'id')
-                    required.add(key);
-        }
-        return { name: componentName, properties: [...properties].map(([propertyName, propertySchema]) => ({ name: propertyName, type: JSON.stringify(propertySchema), required: required.has(propertyName) })) };
-    });
-    return { id: String(catalog.catalogId ?? catalog.$id ?? ''), name, hash: sourceHash ?? createHash('sha256').update(raw).digest('hex'), components };
-}
-const propertyType = (property, language) => schemaType(JSON.parse(property.type), language);
-const header = (model, comment) => `${comment} Generated by omochi-ui from catalog ${model.id}\n${comment} Source SHA-256: ${model.hash}\n`;
-function typescript(model) {
-    const body = model.components.map((component) => `export interface ${component.name}Props {\n${component.properties.map((property) => `  ${JSON.stringify(property.name)}${property.required ? '' : '?'}: ${propertyType(property, 'ts')}`).join('\n')}\n}`).join('\n\n');
-    const map = model.components.map((component) => `  ${JSON.stringify(component.name)}: ${component.name}Props`).join('\n');
-    const knownTypes = ['Accessibility', 'CheckRule', 'DataBinding', 'DynamicBoolean', 'DynamicNumber', 'DynamicString', 'DynamicStringList', 'DynamicValue', 'FunctionCall', 'WireAction'];
-    const imports = ['CatalogDefinition', ...knownTypes.filter((name) => body.includes(name))];
-    return `${header(model, '//')}import type { ${imports.join(', ')} } from '@omochi-ui/sdk'\n\n${body}\n\nexport interface ${model.name}ComponentMap {\n${map}\n}\n\nexport const ${model.name.toUpperCase()}: CatalogDefinition<${model.name}ComponentMap> = { id: ${JSON.stringify(model.id)}, name: ${JSON.stringify(model.name)} }\n`;
-}
-function python(model) {
-    const body = model.components.map((component) => `class ${component.name}Props(TypedDict, total=False):\n${component.properties.map((property) => `    ${property.name}: ${property.required ? 'Required[' : ''}${propertyType(property, 'py')}${property.required ? ']' : ''}`).join('\n') || '    pass'}`).join('\n\n');
-    const overloads = model.components.map((component) => `    @overload\n    def component(self, component: Literal[${JSON.stringify(component.name)}], *, key: str, **props: Unpack[${component.name}Props]) -> None: ...`).join('\n');
-    return `${header(model, '#')}from typing import Any, Literal, Required, TypedDict, Unpack, overload\nfrom omochi_ui import Catalog, UI\nfrom omochi_ui.catalog import DataBinding, DynamicBoolean, DynamicNumber, DynamicString, DynamicStringList, FunctionCall\n\n${body}\n\nclass ${model.name}UI(UI):\n${overloads}\n    def component(self, component: str, *, key: str, **props: Any) -> None:\n        super().component(component, key=key, **props)\n\n${model.name.toUpperCase()} = Catalog(id=${JSON.stringify(model.id)}, name=${JSON.stringify(model.name)}, ui_type=${model.name}UI)\n`;
-}
-function rust(model) {
-    const enumName = (component, property) => `${identifier(component.name)}${identifier(property.name[0].toUpperCase() + property.name.slice(1))}`;
-    const enums = model.components.flatMap((component) => component.properties.flatMap((property) => {
-        const values = JSON.parse(property.type).enum;
-        if (!Array.isArray(values))
-            return [];
-        const variants = values.map((value) => {
-            const raw = String(value);
-            const variant = identifier(raw[0].toUpperCase() + raw.slice(1)) || 'Value';
-            return `    #[serde(rename = ${JSON.stringify(raw)})]\n    ${/^\d/.test(variant) ? `Value${variant}` : variant},`;
-        }).join('\n');
-        return [`#[derive(Clone, Debug, Serialize)]\npub enum ${enumName(component, property)} {\n${variants}\n}`];
-    })).join('\n\n');
-    const body = model.components.map((component) => `#[derive(Clone, Debug, Serialize)]\n#[serde(rename_all = "camelCase")]\npub struct ${component.name}Props {\n${component.properties.map((property) => {
-        const schema = JSON.parse(property.type);
-        const type = Array.isArray(schema.enum) ? enumName(component, property) : propertyType(property, 'rs');
-        return `${property.required ? '' : '    #[serde(skip_serializing_if = "Option::is_none")]\n'}    pub ${snake(property.name)}: ${property.required ? type : `Option<${type}>`},`;
-    }).join('\n')}\n}\nimpl ComponentProps for ${component.name}Props {\n    const NAME: &'static str = ${JSON.stringify(component.name)};\n    fn into_props(self) -> JsonObject { serde_json::to_value(self).unwrap().as_object().unwrap().clone() }\n}`).join('\n\n');
-    return `${header(model, '//')}use omochi_ui::{ComponentProps, JsonObject};\nuse serde::Serialize;\nuse serde_json::Value;\n\npub const CATALOG_ID: &str = ${JSON.stringify(model.id)};\n\n${enums}${enums ? '\n\n' : ''}${body}\n`;
-}
-async function output(path, content, check) {
-    const current = await readFile(path, 'utf8').catch(() => null);
-    if (check) {
-        if (current !== content)
-            throw new Error(`generated catalog is stale: ${path}`);
-        return;
-    }
-    if (current !== content)
-        await writeFile(path, content);
-}
-export async function generateCatalog(options) {
-    if (!options.typescript && !options.python && !options.rust)
-        throw new Error('at least one output flag is required');
-    const raw = await readFile(options.catalog, 'utf8');
-    const parsed = JSON.parse(raw);
-    const resolved = await resolveLocalRefs(parsed, parsed, dirname(resolve(options.catalog)));
-    const model = normalize(JSON.stringify(resolved), options.name, createHash('sha256').update(raw).digest('hex'));
-    await Promise.all([
-        options.typescript ? output(options.typescript, typescript(model), Boolean(options.check)) : undefined,
-        options.python ? output(options.python, python(model), Boolean(options.check)) : undefined,
-        options.rust ? output(options.rust, rust(model), Boolean(options.check)) : undefined,
-    ]);
-}

package/dist/cli.d.ts

@@ -1,2 +0,0 @@
-#!/usr/bin/env bun
-export {};