@knowledge-medium/agent-cli 0.1.0

package/dist/kernel-types/packages/agent-cli/src/protocol.d.ts

@@ -0,0 +1,470 @@
+/**
+ * Wire-protocol schemas shared between the CLI (`cli.ts`) and the
+ * local bridge HTTP server (`server.ts`). Both ends parse JSON over
+ * the wire — the schemas here are the single source of truth for the
+ * shape of those messages, and `z.infer<>` produces the matching
+ * TypeScript types so neither side drifts.
+ *
+ * Conventions:
+ *   - Use `z.looseObject({...})` for envelopes that pass extra fields
+ *     through to a downstream handler (notably command bodies, which
+ *     are forwarded verbatim to the browser-side kernel).
+ *   - Use plain `z.object({...})` (strip extras) for responses we own
+ *     end-to-end — the bridge can shed unknown keys silently rather
+ *     than ferry them to callers.
+ */
+import { z } from 'zod';
+export declare const tokenScopeSchema: z.ZodEnum<{
+    "read-only": "read-only";
+    "read-write": "read-write";
+}>;
+export type TokenScope = z.infer<typeof tokenScopeSchema>;
+export declare const audienceSchema: z.ZodObject<{
+    userId: z.ZodNullable<z.ZodString>;
+    workspaceId: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type Audience = z.infer<typeof audienceSchema>;
+export declare const tokenAudienceSchema: z.ZodObject<{
+    userId: z.ZodNullable<z.ZodString>;
+    workspaceId: z.ZodNullable<z.ZodString>;
+    label: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type TokenAudience = z.infer<typeof tokenAudienceSchema>;
+/**
+ * Wire envelope for every command body POSTed to /runtime/commands.
+ * Only the `type` discriminator is mandatory; the rest of the keys
+ * are command-specific and pass through to the kernel handler.
+ *
+ * This is the *bridge-side* schema — intentionally loose so the bridge
+ * forwards anything with a string `type` to the kernel. The strict,
+ * per-verb shapes live in `knownCommandSchema` below and are what CLI
+ * construction sites + the kernel dispatch switch type-check against.
+ */
+export declare const commandPayloadSchema: z.ZodObject<{
+    type: z.ZodString;
+}, z.core.$loose>;
+export type CommandPayload = z.infer<typeof commandPayloadSchema>;
+export declare const pingCommandSchema: z.ZodObject<{
+    commandId: z.ZodOptional<z.ZodString>;
+    type: z.ZodLiteral<"ping">;
+}, z.core.$loose>;
+export declare const runtimeSummaryCommandSchema: z.ZodObject<{
+    commandId: z.ZodOptional<z.ZodString>;
+    type: z.ZodLiteral<"runtime-summary">;
+}, z.core.$loose>;
+export declare const describeRuntimeCommandSchema: z.ZodObject<{
+    commandId: z.ZodOptional<z.ZodString>;
+    type: z.ZodLiteral<"describe-runtime">;
+    actions: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    facets: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    guides: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    guide: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+    modules: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    components: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    storage: z.ZodOptional<z.ZodBoolean>;
+    brief: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$loose>;
+export declare const sqlModeSchema: z.ZodEnum<{
+    optional: "optional";
+    get: "get";
+    execute: "execute";
+    all: "all";
+}>;
+export type SqlMode = z.infer<typeof sqlModeSchema>;
+export declare const sqlCommandSchema: z.ZodObject<{
+    commandId: z.ZodOptional<z.ZodString>;
+    type: z.ZodLiteral<"sql">;
+    sql: z.ZodString;
+    mode: z.ZodOptional<z.ZodEnum<{
+        optional: "optional";
+        get: "get";
+        execute: "execute";
+        all: "all";
+    }>>;
+    params: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
+}, z.core.$loose>;
+export declare const getBlockCommandSchema: z.ZodObject<{
+    commandId: z.ZodOptional<z.ZodString>;
+    type: z.ZodLiteral<"get-block">;
+    id: z.ZodOptional<z.ZodString>;
+    blockId: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>;
+export declare const getSubtreeCommandSchema: z.ZodObject<{
+    commandId: z.ZodOptional<z.ZodString>;
+    type: z.ZodLiteral<"get-subtree">;
+    rootId: z.ZodString;
+    includeRoot: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$loose>;
+export declare const createBlockCommandSchema: z.ZodObject<{
+    commandId: z.ZodOptional<z.ZodString>;
+    type: z.ZodLiteral<"create-block">;
+    parentId: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>;
+export declare const updateBlockCommandSchema: z.ZodObject<{
+    commandId: z.ZodOptional<z.ZodString>;
+    type: z.ZodLiteral<"update-block">;
+    id: z.ZodOptional<z.ZodString>;
+    blockId: z.ZodOptional<z.ZodString>;
+    content: z.ZodOptional<z.ZodString>;
+    replaceProperties: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$loose>;
+export declare const installExtensionCommandSchema: z.ZodObject<{
+    commandId: z.ZodOptional<z.ZodString>;
+    type: z.ZodLiteral<"install-extension">;
+    source: z.ZodString;
+    label: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    parentId: z.ZodOptional<z.ZodString>;
+    id: z.ZodOptional<z.ZodString>;
+    reload: z.ZodOptional<z.ZodBoolean>;
+    verify: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$loose>;
+export declare const enableExtensionCommandSchema: z.ZodObject<{
+    commandId: z.ZodOptional<z.ZodString>;
+    type: z.ZodLiteral<"enable-extension">;
+    id: z.ZodOptional<z.ZodString>;
+    label: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>;
+export declare const disableExtensionCommandSchema: z.ZodObject<{
+    commandId: z.ZodOptional<z.ZodString>;
+    type: z.ZodLiteral<"disable-extension">;
+    id: z.ZodOptional<z.ZodString>;
+    label: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>;
+/** Legacy alias for enable/disable-extension — accepts an explicit
+ *  `enabled: boolean` field. Not surfaced in the CLI but kept in the
+ *  kernel-handled union so older callers (or arbitrary `kmagent raw`
+ *  bodies) keep working. */
+export declare const setExtensionEnabledCommandSchema: z.ZodObject<{
+    commandId: z.ZodOptional<z.ZodString>;
+    type: z.ZodLiteral<"set-extension-enabled">;
+    id: z.ZodOptional<z.ZodString>;
+    label: z.ZodOptional<z.ZodString>;
+    enabled: z.ZodBoolean;
+}, z.core.$loose>;
+export declare const uninstallExtensionCommandSchema: z.ZodObject<{
+    commandId: z.ZodOptional<z.ZodString>;
+    type: z.ZodLiteral<"uninstall-extension">;
+    id: z.ZodOptional<z.ZodString>;
+    label: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>;
+export declare const runActionCommandSchema: z.ZodObject<{
+    commandId: z.ZodOptional<z.ZodString>;
+    type: z.ZodLiteral<"run-action">;
+    id: z.ZodString;
+    dependencies: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$loose>;
+/** Legacy alias — the kernel handles `'action'` the same way as
+ *  `'run-action'`. Kept in the union so the kernel switch can match
+ *  it after narrowing. */
+export declare const actionCommandSchema: z.ZodObject<{
+    commandId: z.ZodOptional<z.ZodString>;
+    type: z.ZodLiteral<"action">;
+    id: z.ZodString;
+    dependencies: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$loose>;
+export declare const evalCommandSchema: z.ZodObject<{
+    commandId: z.ZodOptional<z.ZodString>;
+    type: z.ZodLiteral<"eval">;
+    code: z.ZodString;
+    data: z.ZodOptional<z.ZodUnknown>;
+}, z.core.$loose>;
+/** Canonical commands the CLI emits. The 1:1 mapping to kmagent
+ *  verbs makes this the right type for CLI construction sites. */
+export declare const knownCommandSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    commandId: z.ZodOptional<z.ZodString>;
+    type: z.ZodLiteral<"ping">;
+}, z.core.$loose>, z.ZodObject<{
+    commandId: z.ZodOptional<z.ZodString>;
+    type: z.ZodLiteral<"runtime-summary">;
+}, z.core.$loose>, z.ZodObject<{
+    commandId: z.ZodOptional<z.ZodString>;
+    type: z.ZodLiteral<"describe-runtime">;
+    actions: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    facets: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    guides: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    guide: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+    modules: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    components: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    storage: z.ZodOptional<z.ZodBoolean>;
+    brief: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$loose>, z.ZodObject<{
+    commandId: z.ZodOptional<z.ZodString>;
+    type: z.ZodLiteral<"sql">;
+    sql: z.ZodString;
+    mode: z.ZodOptional<z.ZodEnum<{
+        optional: "optional";
+        get: "get";
+        execute: "execute";
+        all: "all";
+    }>>;
+    params: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
+}, z.core.$loose>, z.ZodObject<{
+    commandId: z.ZodOptional<z.ZodString>;
+    type: z.ZodLiteral<"get-block">;
+    id: z.ZodOptional<z.ZodString>;
+    blockId: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>, z.ZodObject<{
+    commandId: z.ZodOptional<z.ZodString>;
+    type: z.ZodLiteral<"get-subtree">;
+    rootId: z.ZodString;
+    includeRoot: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$loose>, z.ZodObject<{
+    commandId: z.ZodOptional<z.ZodString>;
+    type: z.ZodLiteral<"create-block">;
+    parentId: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>, z.ZodObject<{
+    commandId: z.ZodOptional<z.ZodString>;
+    type: z.ZodLiteral<"update-block">;
+    id: z.ZodOptional<z.ZodString>;
+    blockId: z.ZodOptional<z.ZodString>;
+    content: z.ZodOptional<z.ZodString>;
+    replaceProperties: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$loose>, z.ZodObject<{
+    commandId: z.ZodOptional<z.ZodString>;
+    type: z.ZodLiteral<"install-extension">;
+    source: z.ZodString;
+    label: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    parentId: z.ZodOptional<z.ZodString>;
+    id: z.ZodOptional<z.ZodString>;
+    reload: z.ZodOptional<z.ZodBoolean>;
+    verify: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$loose>, z.ZodObject<{
+    commandId: z.ZodOptional<z.ZodString>;
+    type: z.ZodLiteral<"enable-extension">;
+    id: z.ZodOptional<z.ZodString>;
+    label: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>, z.ZodObject<{
+    commandId: z.ZodOptional<z.ZodString>;
+    type: z.ZodLiteral<"disable-extension">;
+    id: z.ZodOptional<z.ZodString>;
+    label: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>, z.ZodObject<{
+    commandId: z.ZodOptional<z.ZodString>;
+    type: z.ZodLiteral<"uninstall-extension">;
+    id: z.ZodOptional<z.ZodString>;
+    label: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>, z.ZodObject<{
+    commandId: z.ZodOptional<z.ZodString>;
+    type: z.ZodLiteral<"run-action">;
+    id: z.ZodString;
+    dependencies: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$loose>, z.ZodObject<{
+    commandId: z.ZodOptional<z.ZodString>;
+    type: z.ZodLiteral<"eval">;
+    code: z.ZodString;
+    data: z.ZodOptional<z.ZodUnknown>;
+}, z.core.$loose>], "type">;
+/** Strict shape for any known wire command. CLI authors construct
+ *  these; the kernel narrows on `.type` in its dispatch switch. */
+export type KnownCommand = z.infer<typeof knownCommandSchema>;
+/** The literal string union of every known wire command type. */
+export type KnownCommandType = KnownCommand['type'];
+/** Full set of commands the kernel handles — canonical + legacy
+ *  aliases (`set-extension-enabled`, `action`). Used by the bridge
+ *  to validate incoming commands and by the kernel's executeCommand
+ *  switch for exhaustive narrowing. */
+export declare const knownAgentCommandSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    commandId: z.ZodOptional<z.ZodString>;
+    type: z.ZodLiteral<"ping">;
+}, z.core.$loose>, z.ZodObject<{
+    commandId: z.ZodOptional<z.ZodString>;
+    type: z.ZodLiteral<"runtime-summary">;
+}, z.core.$loose>, z.ZodObject<{
+    commandId: z.ZodOptional<z.ZodString>;
+    type: z.ZodLiteral<"describe-runtime">;
+    actions: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    facets: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    guides: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    guide: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+    modules: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    components: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    storage: z.ZodOptional<z.ZodBoolean>;
+    brief: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$loose>, z.ZodObject<{
+    commandId: z.ZodOptional<z.ZodString>;
+    type: z.ZodLiteral<"sql">;
+    sql: z.ZodString;
+    mode: z.ZodOptional<z.ZodEnum<{
+        optional: "optional";
+        get: "get";
+        execute: "execute";
+        all: "all";
+    }>>;
+    params: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
+}, z.core.$loose>, z.ZodObject<{
+    commandId: z.ZodOptional<z.ZodString>;
+    type: z.ZodLiteral<"get-block">;
+    id: z.ZodOptional<z.ZodString>;
+    blockId: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>, z.ZodObject<{
+    commandId: z.ZodOptional<z.ZodString>;
+    type: z.ZodLiteral<"get-subtree">;
+    rootId: z.ZodString;
+    includeRoot: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$loose>, z.ZodObject<{
+    commandId: z.ZodOptional<z.ZodString>;
+    type: z.ZodLiteral<"create-block">;
+    parentId: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>, z.ZodObject<{
+    commandId: z.ZodOptional<z.ZodString>;
+    type: z.ZodLiteral<"update-block">;
+    id: z.ZodOptional<z.ZodString>;
+    blockId: z.ZodOptional<z.ZodString>;
+    content: z.ZodOptional<z.ZodString>;
+    replaceProperties: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$loose>, z.ZodObject<{
+    commandId: z.ZodOptional<z.ZodString>;
+    type: z.ZodLiteral<"install-extension">;
+    source: z.ZodString;
+    label: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    parentId: z.ZodOptional<z.ZodString>;
+    id: z.ZodOptional<z.ZodString>;
+    reload: z.ZodOptional<z.ZodBoolean>;
+    verify: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$loose>, z.ZodObject<{
+    commandId: z.ZodOptional<z.ZodString>;
+    type: z.ZodLiteral<"enable-extension">;
+    id: z.ZodOptional<z.ZodString>;
+    label: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>, z.ZodObject<{
+    commandId: z.ZodOptional<z.ZodString>;
+    type: z.ZodLiteral<"disable-extension">;
+    id: z.ZodOptional<z.ZodString>;
+    label: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>, z.ZodObject<{
+    commandId: z.ZodOptional<z.ZodString>;
+    type: z.ZodLiteral<"set-extension-enabled">;
+    id: z.ZodOptional<z.ZodString>;
+    label: z.ZodOptional<z.ZodString>;
+    enabled: z.ZodBoolean;
+}, z.core.$loose>, z.ZodObject<{
+    commandId: z.ZodOptional<z.ZodString>;
+    type: z.ZodLiteral<"uninstall-extension">;
+    id: z.ZodOptional<z.ZodString>;
+    label: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>, z.ZodObject<{
+    commandId: z.ZodOptional<z.ZodString>;
+    type: z.ZodLiteral<"run-action">;
+    id: z.ZodString;
+    dependencies: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$loose>, z.ZodObject<{
+    commandId: z.ZodOptional<z.ZodString>;
+    type: z.ZodLiteral<"action">;
+    id: z.ZodString;
+    dependencies: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$loose>, z.ZodObject<{
+    commandId: z.ZodOptional<z.ZodString>;
+    type: z.ZodLiteral<"eval">;
+    code: z.ZodString;
+    data: z.ZodOptional<z.ZodUnknown>;
+}, z.core.$loose>], "type">;
+export type KnownAgentCommand = z.infer<typeof knownAgentCommandSchema>;
+export interface KnownCommandMeta {
+    /** CLI usage example, including positional + flag hints. Phrased as
+     *  the user would type it via the published bin (`kmagent X`); the
+     *  monorepo `yarn agent X` wrapper invokes the same binary. */
+    usage: string;
+    /** Short one-line description for help / summary surfaces. */
+    description: string;
+}
+/** Schema-derived registry of every known wire command. Typed as
+ *  `Record<KnownCommandType, …>` so adding a variant to
+ *  `knownCommandSchema` without a registry entry is a TypeScript
+ *  error — the two sources of truth stay structurally in sync.
+ *
+ *  Consumers should reach for `getCommandMeta(type)` when they want a
+ *  specific entry, or iterate over the registry's entries (e.g. to
+ *  build a CLI help list, a runtime-summary hint set, or a README
+ *  cheatsheet). */
+export declare const knownCommandRegistry: Record<KnownCommandType, KnownCommandMeta>;
+/** Lookup helper for surfaces that want a single command's metadata.
+ *  Type-safe — TypeScript guarantees every `KnownCommandType` resolves. */
+export declare const getCommandMeta: (type: KnownCommandType) => KnownCommandMeta;
+export declare const commandStatusSchema: z.ZodEnum<{
+    pending: "pending";
+    delivered: "delivered";
+    completed: "completed";
+    failed: "failed";
+}>;
+export type CommandStatus = z.infer<typeof commandStatusSchema>;
+/**
+ * What the kernel returns inside a command result envelope. The
+ * `value` (on ok) and `error.message` (on failure) are the only
+ * fields the CLI reads directly; everything else stays opaque.
+ */
+export declare const commandResultSchema: z.ZodNullable<z.ZodObject<{
+    ok: z.ZodBoolean;
+    value: z.ZodOptional<z.ZodUnknown>;
+    error: z.ZodOptional<z.ZodObject<{
+        name: z.ZodOptional<z.ZodString>;
+        message: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>>;
+}, z.core.$strip>>;
+export type CommandResult = z.infer<typeof commandResultSchema>;
+/** Shape returned by GET /runtime/commands/<id> — slice of the
+ *  internal CommandRecord visible over the wire. */
+export declare const commandStatusResponseSchema: z.ZodObject<{
+    id: z.ZodString;
+    status: z.ZodEnum<{
+        pending: "pending";
+        delivered: "delivered";
+        completed: "completed";
+        failed: "failed";
+    }>;
+    result: z.ZodNullable<z.ZodObject<{
+        ok: z.ZodBoolean;
+        value: z.ZodOptional<z.ZodUnknown>;
+        error: z.ZodOptional<z.ZodObject<{
+            name: z.ZodOptional<z.ZodString>;
+            message: z.ZodOptional<z.ZodString>;
+        }, z.core.$loose>>;
+    }, z.core.$strip>>;
+    clientId: z.ZodNullable<z.ZodString>;
+    targetClientId: z.ZodString;
+    createdAt: z.ZodNumber;
+    deliveredAt: z.ZodNullable<z.ZodNumber>;
+    completedAt: z.ZodNullable<z.ZodNumber>;
+}, z.core.$strip>;
+export type CommandStatusResponse = z.infer<typeof commandStatusResponseSchema>;
+export declare const whoamiInfoSchema: z.ZodObject<{
+    clientId: z.ZodString;
+    audience: z.ZodObject<{
+        userId: z.ZodNullable<z.ZodString>;
+        workspaceId: z.ZodNullable<z.ZodString>;
+        label: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>;
+    scope: z.ZodEnum<{
+        "read-only": "read-only";
+        "read-write": "read-write";
+    }>;
+    connected: z.ZodBoolean;
+    clientLastSeen: z.ZodNullable<z.ZodNumber>;
+}, z.core.$strip>;
+export type WhoamiInfo = z.infer<typeof whoamiInfoSchema>;
+/**
+ * One entry of `metadata.tokens` — the client lists each token it
+ * authorizes here. Only `token` is structurally required; the rest are
+ * optional. `scope` is validated downstream by `tokenScope(...)` so a
+ * misspelling falls back to 'read-write' rather than rejecting the
+ * whole client registration.
+ */
+export declare const registerTokenSpecSchema: z.ZodObject<{
+    token: z.ZodString;
+    userId: z.ZodOptional<z.ZodString>;
+    workspaceId: z.ZodOptional<z.ZodString>;
+    label: z.ZodOptional<z.ZodString>;
+    scope: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>;
+export type RegisterTokenSpec = z.infer<typeof registerTokenSpecSchema>;
+export declare const registerClientMetadataSchema: z.ZodObject<{
+    tokens: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
+    audience: z.ZodOptional<z.ZodObject<{
+        userId: z.ZodOptional<z.ZodString>;
+        workspaceId: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>>;
+}, z.core.$loose>;
+export type RegisterClientMetadata = z.infer<typeof registerClientMetadataSchema>;
+//# sourceMappingURL=protocol.d.ts.map

package/dist/kernel-types/packages/agent-cli/src/protocol.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"protocol.d.ts","sourceRoot":"","sources":["../../../../../src/protocol.ts"],"names":[],"mappings":"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"}

package/dist/kernel-types/src/App.d.ts

@@ -0,0 +1,3 @@
+declare const App: () => import("react/jsx-runtime").JSX.Element;
+export default App;
+//# sourceMappingURL=App.d.ts.map

package/dist/kernel-types/src/App.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"App.d.ts","sourceRoot":"","sources":["../../../../../src/App.tsx"],"names":[],"mappings":"AA8TA,QAAA,MAAM,GAAG,+CAqER,CAAA;AAED,eAAe,GAAG,CAAA"}

package/dist/kernel-types/src/components/BlockComponent.d.ts

@@ -0,0 +1,21 @@
+import { Block } from '../data/block';
+interface BlockComponentProps {
+    blockId: string;
+}
+export declare function BlockComponent({ blockId }: BlockComponentProps): import("react/jsx-runtime").JSX.Element;
+/**
+ * An interesting idea here is to keep building the context as we go deeper,
+ * so push all the properties from the parent to the context - overrides would automatically happen in the hierarchy
+ * we can also add things like "youtube parent" and such
+ *
+ * two concerns:
+ * - memory usage
+ * - this diverges the behavior in ui vs pure block operation, given the block in isolation, we won't have the context
+ *
+ * youtube context seems more immediately meaningful/actionable
+ */
+export declare const BlockChildren: ({ block }: {
+    block: Block;
+}) => import("react/jsx-runtime").JSX.Element;
+export {};
+//# sourceMappingURL=BlockComponent.d.ts.map

package/dist/kernel-types/src/components/BlockComponent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BlockComponent.d.ts","sourceRoot":"","sources":["../../../../../../src/components/BlockComponent.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,eAAe,CAAA;AAWrC,UAAU,mBAAmB;IAC3B,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,wBAAgB,cAAc,CAAC,EAAC,OAAO,EAAC,EAAE,mBAAmB,2CAkB5D;AAED;;;;;;;;;;GAUG;AACH,eAAO,MAAM,aAAa,GAAI,WAAS;IAAE,KAAK,EAAE,KAAK,CAAA;CAAE,4CAatD,CAAA"}

package/dist/kernel-types/src/components/BlockEditor.d.ts

@@ -0,0 +1,18 @@
+import { ReactCodeMirrorRef, ReactCodeMirrorProps } from '@uiw/react-codemirror';
+import { Block } from '../data/block';
+import { type Ref } from 'react';
+interface BlockEditorProps extends Omit<ReactCodeMirrorProps, 'value' | 'onChange' | 'onUpdate' | 'onBlur' | 'ref'> {
+    block: Block;
+    ref?: Ref<ReactCodeMirrorRef>;
+}
+/** Acquire one hold on the suppression. Returns the release fn;
+ *  callers MUST schedule the release on their own timer or via finally.
+ *  Idempotent — the returned fn is safe to call more than once but
+ *  only decrements the count once. */
+export declare const acquireBlurExitSuppression: () => (() => void);
+export declare const BlockEditor: {
+    ({ block, ref, ...codeMirrorProps }: BlockEditorProps): import("react/jsx-runtime").JSX.Element | null;
+    displayName: string;
+};
+export {};
+//# sourceMappingURL=BlockEditor.d.ts.map

package/dist/kernel-types/src/components/BlockEditor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BlockEditor.d.ts","sourceRoot":"","sources":["../../../../../../src/components/BlockEditor.tsx"],"names":[],"mappings":"AAAA,OAAmB,EAAE,kBAAkB,EAAE,oBAAoB,EAAE,MAAM,uBAAuB,CAAA;AAC5F,OAAO,EAAE,KAAK,EAAE,MAAM,eAAe,CAAA;AAOrC,OAAO,EAAqD,KAAK,GAAG,EAAE,MAAM,OAAO,CAAA;AAUnF,UAAU,gBAAiB,SAAQ,IAAI,CAAC,oBAAoB,EAAE,OAAO,GAAG,UAAU,GAAG,UAAU,GAAG,QAAQ,GAAG,KAAK,CAAC;IACjH,KAAK,EAAE,KAAK,CAAA;IACZ,GAAG,CAAC,EAAE,GAAG,CAAC,kBAAkB,CAAC,CAAA;CAC9B;AAYD;;;sCAGsC;AACtC,eAAO,MAAM,0BAA0B,QAAO,CAAC,MAAM,IAAI,CAQxD,CAAA;AAED,eAAO,MAAM,WAAW;yCAIrB,gBAAgB;;CAoOlB,CAAA"}

package/dist/kernel-types/src/components/BlockLoadingPlaceholder.d.ts

@@ -0,0 +1,15 @@
+interface BlockLoadingPlaceholderProps {
+    /** Caller-supplied size — `LazyViewportMount` passes the last
+     *  measured height so reserved space matches the real block. Omitted
+     *  by callers that have no measurement (e.g. `BlockComponent`'s
+     *  Suspense fallback), in which case we fall back to a single-line
+     *  estimate so the placeholder still occupies a reasonable frame. */
+    reservedHeight?: number;
+}
+/**
+ * Mirrors the default block flex shape so lazy content slots into the
+ * same visual frame instead of materializing from an empty gap.
+ */
+export declare function BlockLoadingPlaceholder({ reservedHeight, }: BlockLoadingPlaceholderProps): import("react/jsx-runtime").JSX.Element;
+export {};
+//# sourceMappingURL=BlockLoadingPlaceholder.d.ts.map

package/dist/kernel-types/src/components/BlockLoadingPlaceholder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BlockLoadingPlaceholder.d.ts","sourceRoot":"","sources":["../../../../../../src/components/BlockLoadingPlaceholder.tsx"],"names":[],"mappings":"AAGA,UAAU,4BAA4B;IACpC;;;;yEAIqE;IACrE,cAAc,CAAC,EAAE,MAAM,CAAA;CACxB;AAQD;;;GAGG;AACH,wBAAgB,uBAAuB,CAAC,EACtC,cAA2C,GAC5C,EAAE,4BAA4B,2CAkB9B"}

package/dist/kernel-types/src/components/BlockProperties.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Property panel shell. The lookup chain/model lives in
+ * `propertyPanel/model.ts`; row actions live in `propertyPanel/actions.ts`;
+ * row/add/config UI lives under `propertyPanel/`.
+ */
+import { Block } from '../data/block';
+interface BlockPropertiesProps {
+    block: Block;
+}
+export declare function BlockProperties({ block }: BlockPropertiesProps): import("react/jsx-runtime").JSX.Element | null;
+export {};
+//# sourceMappingURL=BlockProperties.d.ts.map

package/dist/kernel-types/src/components/BlockProperties.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BlockProperties.d.ts","sourceRoot":"","sources":["../../../../../../src/components/BlockProperties.tsx"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH,OAAO,EAAE,KAAK,EAAE,MAAM,eAAe,CAAA;AA+BrC,UAAU,oBAAoB;IAC5B,KAAK,EAAE,KAAK,CAAA;CACb;AAYD,wBAAgB,eAAe,CAAC,EAAC,KAAK,EAAC,EAAE,oBAAoB,kDAwR5D"}

package/dist/kernel-types/src/components/Header.d.ts

@@ -0,0 +1,2 @@
+export declare function Header(): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=Header.d.ts.map

package/dist/kernel-types/src/components/Header.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Header.d.ts","sourceRoot":"","sources":["../../../../../../src/components/Header.tsx"],"names":[],"mappings":"AAoBA,wBAAgB,MAAM,4CAYrB"}

package/dist/kernel-types/src/components/LazyBlockComponent.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Renders a bullet-shaped placeholder until the block scrolls into (or
+ * near) the viewport, then swaps in the real `<BlockComponent>`.
+ *
+ * The recursive block tree is the natural rendering shape for an
+ * outliner, but mounting every descendant up-front is too expensive
+ * for large pages (each `BlockComponent` carries ~10 `useHandle`
+ * subscriptions through its renderer chain). This wrapper defers the
+ * heavy work to the moment a block is about to be seen, while keeping
+ * the recursive structure intact — backlinks, footers, and indentation
+ * all still come from the regular renderer path.
+ *
+ * Once mounted, a block stays mounted; we don't tear it back down on
+ * scroll-away. Re-mount churn would dominate any RAM win for a few
+ * hundred idle subscriptions.
+ *
+ * Layout stability is handled by the shared lazy viewport wrapper and
+ * block-shaped placeholder: each mounted block records its rendered
+ * height, and future placeholders for the same block reserve that size.
+ *
+ * Test/SSR fallback: the shared wrapper mounts immediately if
+ * `IntersectionObserver` isn't available.
+ */
+interface LazyBlockComponentProps {
+    blockId: string;
+}
+export declare function LazyBlockComponent({ blockId }: LazyBlockComponentProps): import("react/jsx-runtime").JSX.Element;
+export {};
+//# sourceMappingURL=LazyBlockComponent.d.ts.map

package/dist/kernel-types/src/components/LazyBlockComponent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LazyBlockComponent.d.ts","sourceRoot":"","sources":["../../../../../../src/components/LazyBlockComponent.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAgBH,UAAU,uBAAuB;IAC/B,OAAO,EAAE,MAAM,CAAA;CAChB;AAED,wBAAgB,kBAAkB,CAAC,EAAE,OAAO,EAAE,EAAE,uBAAuB,2CAatE"}

package/dist/kernel-types/src/components/Login.d.ts

@@ -0,0 +1,12 @@
+import { ReactNode } from 'react';
+import { User } from '@/types.js';
+export declare const useUser: () => User;
+export declare const useSignOut: () => () => Promise<void>;
+/** True when the active session has remote sync disabled. Use this to gate
+ *  Supabase RPC calls and UI that only makes sense with a remote backend
+ *  (member management, invitations, etc.). */
+export declare const useIsLocalOnly: () => boolean;
+export declare function Login({ children }: {
+    children: ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=Login.d.ts.map

package/dist/kernel-types/src/components/Login.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Login.d.ts","sourceRoot":"","sources":["../../../../../../src/components/Login.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAkD,SAAS,EAAa,MAAM,OAAO,CAAA;AAI5F,OAAO,EAAE,IAAI,EAAE,MAAM,YAAY,CAAA;AAmBjC,eAAO,MAAM,OAAO,YAInB,CAAA;AAED,eAAO,MAAM,UAAU,cAjBN,OAAO,CAAC,IAAI,CAqB5B,CAAA;AAED;;8CAE8C;AAC9C,eAAO,MAAM,cAAc,eAI1B,CAAA;AAYD,wBAAgB,KAAK,CAAC,EAAC,QAAQ,EAAC,EAAE;IAAE,QAAQ,EAAE,SAAS,CAAA;CAAE,2CAyBxD"}

package/dist/kernel-types/src/components/propertyEditors/RefPropertyEditor.d.ts

@@ -0,0 +1,13 @@
+import { type PropertyEditorProps } from '@/data/api';
+import { Block } from '@/data/block';
+export declare function ReferenceSearch({ owner, excludeIds, targetTypes, placeholder, selectionMode, onPick, }: {
+    owner: Block;
+    excludeIds: readonly string[];
+    targetTypes: readonly string[];
+    placeholder: string;
+    selectionMode: 'single' | 'multiple';
+    onPick: (blockId: string) => void;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function RefPropertyEditor(props: PropertyEditorProps<string>): import("react/jsx-runtime").JSX.Element;
+export declare function RefListPropertyEditor(props: PropertyEditorProps<readonly string[]>): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=RefPropertyEditor.d.ts.map

package/dist/kernel-types/src/components/propertyEditors/RefPropertyEditor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RefPropertyEditor.d.ts","sourceRoot":"","sources":["../../../../../../../src/components/propertyEditors/RefPropertyEditor.tsx"],"names":[],"mappings":"AAEA,OAAO,EAGL,KAAK,mBAAmB,EAEzB,MAAM,YAAY,CAAA;AACnB,OAAO,EAAE,KAAK,EAAE,MAAM,cAAc,CAAA;AAkLpC,wBAAgB,eAAe,CAAC,EAC9B,KAAK,EACL,UAAU,EACV,WAAW,EACX,WAAW,EACX,aAAa,EACb,MAAM,GACP,EAAE;IACD,KAAK,EAAE,KAAK,CAAA;IACZ,UAAU,EAAE,SAAS,MAAM,EAAE,CAAA;IAC7B,WAAW,EAAE,SAAS,MAAM,EAAE,CAAA;IAC9B,WAAW,EAAE,MAAM,CAAA;IACnB,aAAa,EAAE,QAAQ,GAAG,UAAU,CAAA;IACpC,MAAM,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAA;CAClC,2CAoJA;AAyFD,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,mBAAmB,CAAC,MAAM,CAAC,2CAGnE;AAED,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,mBAAmB,CAAC,SAAS,MAAM,EAAE,CAAC,2CAGlF"}

package/dist/kernel-types/src/components/propertyEditors/RefTargetTypePicker.d.ts

@@ -0,0 +1,7 @@
+/** Config editor for ref / refList presets. Lets the user constrain
+ *  the property to one or more block types — empty list means "any
+ *  type accepted." Mounted inside the property-schema block renderer
+ *  (the side panel reached via the row's glyph button). */
+import type { RefCodecOptions, ValuePresetConfigEditorProps } from '@/data/api';
+export declare function RefTargetTypePicker({ value, onChange, }: ValuePresetConfigEditorProps<RefCodecOptions>): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=RefTargetTypePicker.d.ts.map