@fungi.computer/agar 0.0.1 → 0.2.0

package/dist/computer-contracts.d.ts

@@ -1,11 +1,11 @@
 import * as z from "zod";
 /** Public metadata for one host-admitted Workflow Git pass; parsing never grants authority. */
-export declare const workflowGitPassResultSchema: z.ZodObject<{
+export declare const workflowGitPassResultSchema: z.ZodLazy<z.ZodObject<{
     passId: z.ZodString;
     remote: z.ZodURL;
     expiresAt: z.ZodNumber;
     bearer: z.ZodExactOptional<z.ZodString>;
-}, z.core.$strict>;
+}, z.core.$strict>>;
 /** The complete remote stays opaque; the host owns admission, renewal and revocation. */
 export type WorkflowGitPassResult = z.output<typeof workflowGitPassResultSchema>;
 /** Existing attachment budget operation kinds shared by Computer and Media. */
@@ -15,7 +15,7 @@ export declare const connectorOperationBudgetKindSchema: z.ZodEnum<{
     exec: "exec";
 }>;
 /** Existing owner budget refusal; it remains a domain result, not a wire envelope. */
-export declare const connectorOperationBudgetRefusalSchema: z.ZodObject<{
+export declare const connectorOperationBudgetRefusalSchema: z.ZodLazy<z.ZodObject<{
     error: z.ZodLiteral<"attachment_budget_exceeded">;
     kind: z.ZodEnum<{
         write: "write";
@@ -23,16 +23,16 @@ export declare const connectorOperationBudgetRefusalSchema: z.ZodObject<{
         exec: "exec";
     }>;
     retryAfterMs: z.ZodNumber;
-}, z.core.$strict>;
+}, z.core.$strict>>;
 /** Computer admission refusals returned before native dispatch. */
-export declare const appComputerAdmissionRefusalSchema: z.ZodUnion<readonly [z.ZodObject<{
+export declare const appComputerAdmissionRefusalSchema: z.ZodLazy<z.ZodUnion<readonly [z.ZodObject<{
     error: z.ZodEnum<{
         unavailable: "unavailable";
         revoked: "revoked";
         not_granted: "not_granted";
         grantor_lost_authority: "grantor_lost_authority";
     }>;
-}, z.core.$strict>, z.ZodObject<{
+}, z.core.$strict>, z.ZodLazy<z.ZodObject<{
     error: z.ZodLiteral<"attachment_budget_exceeded">;
     kind: z.ZodEnum<{
         write: "write";
@@ -40,34 +40,34 @@ export declare const appComputerAdmissionRefusalSchema: z.ZodUnion<readonly [z.Z
         exec: "exec";
     }>;
     retryAfterMs: z.ZodNumber;
-}, z.core.$strict>]>;
+}, z.core.$strict>>]>>;
 /** Existing Computer broker argument refusals. */
-export declare const appComputerInputRefusalSchema: z.ZodObject<{
+export declare const appComputerInputRefusalSchema: z.ZodLazy<z.ZodObject<{
     error: z.ZodEnum<{
         invalid: "invalid";
         too_large: "too_large";
         invalid_path: "invalid_path";
     }>;
-}, z.core.$strict>;
+}, z.core.$strict>>;
 /** Existing Computer dispatch status/decoding refusals. */
-export declare const appComputerDispatchRefusalSchema: z.ZodObject<{
+export declare const appComputerDispatchRefusalSchema: z.ZodLazy<z.ZodObject<{
     error: z.ZodEnum<{
         unavailable: "unavailable";
         conflict: "conflict";
         not_granted: "not_granted";
         too_large: "too_large";
     }>;
-}, z.core.$strict>;
+}, z.core.$strict>>;
 /** An execution wait can time out while its durable request remains identifiable. */
-export declare const appComputerExecTimeoutSchema: z.ZodObject<{
+export declare const appComputerExecTimeoutSchema: z.ZodLazy<z.ZodObject<{
     error: z.ZodLiteral<"timeout">;
     requestId: z.ZodString;
-}, z.core.$strict>;
+}, z.core.$strict>>;
 /** The Workflow Git-pass owner has exactly these existing domain refusals. */
-export declare const workflowGitPassRefusalSchema: z.ZodObject<{
+export declare const workflowGitPassRefusalSchema: z.ZodLazy<z.ZodObject<{
     error: z.ZodEnum<{
         unavailable: "unavailable";
         revoked: "revoked";
         not_granted: "not_granted";
     }>;
-}, z.core.$strict>;
+}, z.core.$strict>>;

package/dist/computer-contracts.js

@@ -1,6 +1,6 @@
 import * as z from "zod";
 /** Public metadata for one host-admitted Workflow Git pass; parsing never grants authority. */
-export const workflowGitPassResultSchema = z.strictObject({
+export const workflowGitPassResultSchema = z.lazy(() => z.strictObject({
     passId: z.string().min(1),
     remote: z.url({ protocol: /^https$/, abort: true }).refine((value) => {
         const remote = new URL(value);
@@ -13,7 +13,7 @@ export const workflowGitPassResultSchema = z.strictObject({
      * command-local Git config, never written to a repository config.
      */
     bearer: z.string().min(1).exactOptional(),
-});
+}));
 /** Existing attachment budget operation kinds shared by Computer and Media. */
 export const connectorOperationBudgetKindSchema = z.enum([
     "exec",
@@ -21,13 +21,13 @@ export const connectorOperationBudgetKindSchema = z.enum([
     "media",
 ]);
 /** Existing owner budget refusal; it remains a domain result, not a wire envelope. */
-export const connectorOperationBudgetRefusalSchema = z.strictObject({
+export const connectorOperationBudgetRefusalSchema = z.lazy(() => z.strictObject({
     error: z.literal("attachment_budget_exceeded"),
     kind: connectorOperationBudgetKindSchema,
     retryAfterMs: z.number(),
-});
+}));
 /** Computer admission refusals returned before native dispatch. */
-export const appComputerAdmissionRefusalSchema = z.union([
+export const appComputerAdmissionRefusalSchema = z.lazy(() => z.union([
     z.strictObject({
         error: z.enum([
             "revoked",
@@ -37,21 +37,21 @@ export const appComputerAdmissionRefusalSchema = z.union([
         ]),
     }),
     connectorOperationBudgetRefusalSchema,
-]);
+]));
 /** Existing Computer broker argument refusals. */
-export const appComputerInputRefusalSchema = z.strictObject({
+export const appComputerInputRefusalSchema = z.lazy(() => z.strictObject({
     error: z.enum(["too_large", "invalid_path", "invalid"]),
-});
+}));
 /** Existing Computer dispatch status/decoding refusals. */
-export const appComputerDispatchRefusalSchema = z.strictObject({
+export const appComputerDispatchRefusalSchema = z.lazy(() => z.strictObject({
     error: z.enum(["not_granted", "too_large", "conflict", "unavailable"]),
-});
+}));
 /** An execution wait can time out while its durable request remains identifiable. */
-export const appComputerExecTimeoutSchema = z.strictObject({
+export const appComputerExecTimeoutSchema = z.lazy(() => z.strictObject({
     error: z.literal("timeout"),
     requestId: z.string(),
-});
+}));
 /** The Workflow Git-pass owner has exactly these existing domain refusals. */
-export const workflowGitPassRefusalSchema = z.strictObject({
+export const workflowGitPassRefusalSchema = z.lazy(() => z.strictObject({
     error: z.enum(["revoked", "not_granted", "unavailable"]),
-});
+}));

package/dist/computer.js

@@ -15,11 +15,11 @@ export const computerListingSchema = Schema.Struct({
     })),
     nextOffset: Schema.NullOr(Schema.Number),
 });
-export const computerList = defineCapability("computer.list", 1, rpcHandleSchema({
+export const computerList = defineCapability("computer.list", 1, z.lazy(() => rpcHandleSchema({
     list: rpcMethod(rpcDataSchema(z
         .unknown()
         .transform((value) => Schema.decodeUnknownSync(computerListingSchema)(value)))),
-}));
+})));
 export const computerRuntimeStateSchema = Schema.Union([
     Schema.Struct({
         state: Schema.Literals(["running", "sleeping", "starting"]),
@@ -50,12 +50,12 @@ export const computerInstrumentSnapshotSchema = Schema.Struct({
     })),
     internet: computerInternetAccessSchema,
 });
-export const computerInstrumentRead = defineCapability("computer.instrument.read", 1, rpcHandleSchema({
+export const computerInstrumentRead = defineCapability("computer.instrument.read", 1, z.lazy(() => rpcHandleSchema({
     read: rpcMethod(rpcDataSchema(z
         .unknown()
         .transform((value) => Schema.decodeUnknownSync(computerInstrumentSnapshotSchema)(value)))),
-}));
-export const computerInstrumentControl = defineCapability("computer.instrument.control", 1, rpcHandleSchema({
+})));
+export const computerInstrumentControl = defineCapability("computer.instrument.control", 1, z.lazy(() => rpcHandleSchema({
     start: rpcMethod(rpcDataSchema(z
         .unknown()
         .transform((value) => Schema.decodeUnknownSync(computerRuntimeStateSchema)(value)))),
@@ -65,7 +65,7 @@ export const computerInstrumentControl = defineCapability("computer.instrument.c
     detachLocal: rpcMethod(rpcDataSchema(z
         .unknown()
         .transform((value) => Schema.decodeUnknownSync(Schema.Struct({ detached: Schema.Boolean }))(value)))),
-}));
+})));
 export async function readComputerInstrument(capabilities) {
     return Schema.decodeUnknownSync(computerInstrumentSnapshotSchema)(await capabilities.require(computerInstrumentRead).read());
 }
@@ -106,7 +106,7 @@ export const computerPortRemovalSchema = Schema.Struct({
     removed: Schema.Boolean,
 });
 /** The selected Computer's admitted preview URLs and port mutations. */
-export const computerPorts = defineCapability("computer.ports", 2, rpcHandleSchema({
+export const computerPorts = defineCapability("computer.ports", 2, z.lazy(() => rpcHandleSchema({
     list: rpcMethod(rpcDataSchema(z
         .unknown()
         .transform((value) => Schema.decodeUnknownSync(computerPortsResultSchema)(value)))),
@@ -116,7 +116,7 @@ export const computerPorts = defineCapability("computer.ports", 2, rpcHandleSche
     unexpose: rpcMethod(rpcDataSchema(z
         .unknown()
         .transform((value) => Schema.decodeUnknownSync(computerPortRemovalSchema)(value)))),
-}));
+})));
 /** Decode exposed ports at the SDK boundary. */
 export async function listComputerPorts(capabilities) {
     const result = Schema.decodeUnknownSync(computerPortsResultSchema)(await capabilities.require(computerPorts).list());
@@ -178,7 +178,7 @@ export const computerProcessStartSchema = Schema.Struct({
     port: Schema.optionalKey(computerPortExposureSchema.fields.port),
 });
 /** Read the authoritative process inventory from the selected Computer. */
-export const computerProcesses = defineCapability("computer.processes", 1, rpcHandleSchema({
+export const computerProcesses = defineCapability("computer.processes", 1, z.lazy(() => rpcHandleSchema({
     start: rpcMethod(rpcDataSchema(z
         .unknown()
         .transform((value) => Schema.decodeUnknownSync(computerProcessSchema)(value)))),
@@ -188,7 +188,7 @@ export const computerProcesses = defineCapability("computer.processes", 1, rpcHa
     kill: rpcMethod(rpcDataSchema(z
         .unknown()
         .transform((value) => Schema.decodeUnknownSync(computerProcessKillSchema)(value)))),
-}));
+})));
 /** Decode the Computer owner's process inventory at the App boundary. */
 export async function listComputerProcesses(capabilities) {
     return Schema.decodeUnknownSync(computerProcessesSchema)(await capabilities.require(computerProcesses).list());
@@ -197,12 +197,12 @@ export async function listComputerProcesses(capabilities) {
 export async function killComputerProcess(capabilities, id) {
     return Schema.decodeUnknownSync(computerProcessKillSchema)(await capabilities.require(computerProcesses).kill(id));
 }
-export const computerReadFile = defineCapability("computer.readFile", 1, rpcHandleSchema({
+export const computerReadFile = defineCapability("computer.readFile", 1, z.lazy(() => rpcHandleSchema({
     open: rpcMethod(rpcHandleSchema({
         response: rpcMethod(z.instanceof(Response)),
         close: rpcVoid,
     })),
-}));
+})));
 /** The caller receives native file bytes; HTTP details stay in the SDK adapter. */
 export async function readComputerFile(capabilities, input, options) {
     return await readAppFile(await capabilities.require(computerReadFile).open(input), { ...options, name: input.path.split("/").at(-1) ?? "file" });
@@ -211,13 +211,13 @@ export async function readComputerFile(capabilities, input, options) {
 export async function listComputerFiles(capabilities, input) {
     return Schema.decodeUnknownSync(computerListingSchema)(await capabilities.require(computerList).list(input));
 }
-export const computerWriteFile = defineCapability("computer.writeFile", 3, rpcHandleSchema({
+export const computerWriteFile = defineCapability("computer.writeFile", 3, z.lazy(() => rpcHandleSchema({
     open: rpcMethod(rpcHandleSchema({ write: rpcVoid, close: rpcVoid })),
     mkdir: rpcVoid,
     replace: rpcMethod(rpcDataSchema(z
         .unknown()
         .transform((value) => Schema.decodeUnknownSync(computerFileReplacementOutcomeSchema)(value)))),
-}));
+})));
 const computerFileReplacementOutcomeSchema = Schema.Union([
     Schema.Struct({
         kind: Schema.Literal("replaced"),
@@ -244,7 +244,7 @@ export const computerTerminalInformationSchema = Schema.Struct({
     uptimeSeconds: Schema.Number.pipe(Schema.check(Schema.isInt()), Schema.check(Schema.isGreaterThanOrEqualTo(0))),
     version: Schema.NonEmptyString.pipe(Schema.check(Schema.isMaxLength(64))),
 });
-export const computerTerminal = defineCapability("computer.terminal", 2, rpcHandleSchema({
+export const computerTerminal = defineCapability("computer.terminal", 2, z.lazy(() => rpcHandleSchema({
     open: rpcMethod(rpcHandleSchema({
         information: rpcMethod(rpcDataSchema(z
             .unknown()
@@ -258,7 +258,7 @@ export const computerTerminal = defineCapability("computer.terminal", 2, rpcHand
         resize: rpcVoid,
         close: rpcVoid,
     })),
-}));
+})));
 /** Open one host-owned terminal and bind its lifetime to the mounted App. */
 export async function openComputerTerminal(capabilities, size, options = {}) {
     options.signal?.throwIfAborted();

package/dist/game-servers.js

@@ -221,7 +221,7 @@ export class GameServerRequestError extends Error {
         this.name = "GameServerRequestError";
     }
 }
-export const gamesServers = defineCapability("games:servers", 1, rpcHandleSchema({
+export const gamesServers = defineCapability("games:servers", 1, z.lazy(() => rpcHandleSchema({
     list: rpcMethod(rpcDataSchema(z.unknown().transform((value) => gameServerPageSchema.parse(value)))),
     catalog: rpcMethod(rpcDataSchema(z
         .unknown()
@@ -236,7 +236,7 @@ export const gamesServers = defineCapability("games:servers", 1, rpcHandleSchema
         .transform((value) => z.array(gameServerBackupSchema).parse(value)))),
     delete: rpcVoid,
     backupNow: rpcVoid,
-}));
+})));
 /** Decode the host's listing at the App boundary. */
 export async function listGameServers(capabilities, input) {
     const page = await capabilities.require(gamesServers).list(input);

package/dist/git-rpc.d.ts

@@ -3,27 +3,27 @@ import { type GitBinding } from "./git.js";
 /** The native tuple and result grammar shared by the handle and frame entrypoint. */
 export declare const nativeGitCodecs: {
     create: {
-        args: z.ZodTuple<[z.ZodString, z.ZodOptional<z.ZodObject<{
+        args: z.ZodTuple<[z.ZodString, z.ZodLazy<z.ZodOptional<z.ZodObject<{
             description: z.ZodOptional<z.ZodString>;
             defaultBranch: z.ZodOptional<z.ZodString>;
-        }, z.core.$strict>>], null>;
-        result: z.ZodObject<{
+        }, z.core.$strict>>>], null>;
+        result: z.ZodLazy<z.ZodObject<{
             name: z.ZodString;
             defaultBranch: z.ZodString;
             lastPushAt: z.ZodNullable<z.ZodString>;
             source: z.ZodNullable<z.ZodString>;
-        }, z.core.$strict>;
+        }, z.core.$strict>>;
     };
     fork: {
-        args: z.ZodTuple<[z.ZodString, z.ZodString, z.ZodOptional<z.ZodObject<{
+        args: z.ZodTuple<[z.ZodString, z.ZodString, z.ZodLazy<z.ZodOptional<z.ZodObject<{
             description: z.ZodOptional<z.ZodString>;
-        }, z.core.$strict>>], null>;
-        result: z.ZodObject<{
+        }, z.core.$strict>>>], null>;
+        result: z.ZodLazy<z.ZodObject<{
             name: z.ZodString;
             defaultBranch: z.ZodString;
             lastPushAt: z.ZodNullable<z.ZodString>;
             source: z.ZodNullable<z.ZodString>;
-        }, z.core.$strict>;
+        }, z.core.$strict>>;
     };
     cloneUrl: {
         args: z.ZodTuple<[z.ZodString], null>;
@@ -31,24 +31,24 @@ export declare const nativeGitCodecs: {
     };
     info: {
         args: z.ZodTuple<[z.ZodString], null>;
-        result: z.ZodNullable<z.ZodObject<{
+        result: z.ZodNullable<z.ZodLazy<z.ZodObject<{
             name: z.ZodString;
             defaultBranch: z.ZodString;
             lastPushAt: z.ZodNullable<z.ZodString>;
             source: z.ZodNullable<z.ZodString>;
-        }, z.core.$strict>>;
+        }, z.core.$strict>>>;
     };
     delete: {
         args: z.ZodTuple<[z.ZodString], null>;
         result: z.ZodBoolean;
     };
     log: {
-        args: z.ZodTuple<[z.ZodString, z.ZodObject<{
+        args: z.ZodTuple<[z.ZodString, z.ZodLazy<z.ZodObject<{
             ref: z.ZodString;
             limit: z.ZodOptional<z.ZodNumber>;
             offset: z.ZodOptional<z.ZodNumber>;
-        }, z.core.$strict>], null>;
-        result: z.ZodArray<z.ZodObject<{
+        }, z.core.$strict>>], null>;
+        result: z.ZodArray<z.ZodLazy<z.ZodObject<{
             hash: z.ZodString;
             treeHash: z.ZodString;
             message: z.ZodString;
@@ -63,11 +63,11 @@ export declare const nativeGitCodecs: {
             parents: z.ZodArray<z.ZodString>;
             authoredAt: z.ZodNumber;
             committedAt: z.ZodNumber;
-        }, z.core.$strict>>;
+        }, z.core.$strict>>>;
     };
     readCommit: {
         args: z.ZodTuple<[z.ZodString, z.ZodString], null>;
-        result: z.ZodNullable<z.ZodObject<{
+        result: z.ZodNullable<z.ZodLazy<z.ZodObject<{
             hash: z.ZodString;
             treeHash: z.ZodString;
             message: z.ZodString;
@@ -82,11 +82,11 @@ export declare const nativeGitCodecs: {
             parents: z.ZodArray<z.ZodString>;
             authoredAt: z.ZodNumber;
             committedAt: z.ZodNumber;
-        }, z.core.$strict>>;
+        }, z.core.$strict>>>;
     };
     readTree: {
         args: z.ZodTuple<[z.ZodString, z.ZodString], null>;
-        result: z.ZodNullable<z.ZodArray<z.ZodObject<{
+        result: z.ZodNullable<z.ZodArray<z.ZodLazy<z.ZodObject<{
             name: z.ZodString;
             mode: z.ZodString;
             hash: z.ZodString;
@@ -95,11 +95,11 @@ export declare const nativeGitCodecs: {
                 tree: "tree";
                 commit: "commit";
             }>;
-        }, z.core.$strict>>>;
+        }, z.core.$strict>>>>;
     };
     readBlob: {
         args: z.ZodTuple<[z.ZodString, z.ZodString], null>;
-        result: z.ZodNullable<z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>>;
+        result: z.ZodNullable<z.ZodLazy<z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>>>;
     };
     refs: {
         args: z.ZodTuple<[z.ZodString], null>;
@@ -118,13 +118,13 @@ export declare const nativeGitCodecs: {
                 advertise: "advertise";
                 exchange: "exchange";
             }>;
-            body: z.ZodNullable<z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>>;
-            headers: z.ZodRecord<z.ZodString, z.ZodString>;
+            body: z.ZodNullable<z.ZodLazy<z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>>>;
+            headers: z.ZodLazy<z.ZodRecord<z.ZodString, z.ZodString>>;
         }, z.core.$strict>], null>;
         result: z.ZodObject<{
             status: z.ZodNumber;
-            headers: z.ZodRecord<z.ZodString, z.ZodString>;
-            body: z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>;
+            headers: z.ZodLazy<z.ZodRecord<z.ZodString, z.ZodString>>;
+            body: z.ZodLazy<z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>>;
         }, z.core.$strict>;
     };
 };

package/dist/git-rpc.js

@@ -1,18 +1,18 @@
 import * as z from "zod";
 import {} from "./git.js";
 import { gitRepositoryNameSchema, gitSha1Schema, } from "@fungi.computer/puffball/git-representation";
-const bytes = z
+const bytes = z.lazy(() => z
     .instanceof(Uint8Array)
-    .refine((value) => value.byteLength <= 32 * 1024 * 1024);
-const headers = z.record(z.string().max(256), z.string().max(8192));
+    .refine((value) => value.byteLength <= 32 * 1024 * 1024));
+const headers = z.lazy(() => z.record(z.string().max(256), z.string().max(8192)));
 const identity = z.strictObject({ name: z.string(), email: z.string() });
-const info = z.strictObject({
+const info = z.lazy(() => z.strictObject({
     name: gitRepositoryNameSchema,
     defaultBranch: z.string(),
     lastPushAt: z.string().nullable(),
     source: gitRepositoryNameSchema.nullable(),
-});
-const commit = z.strictObject({
+}));
+const commit = z.lazy(() => z.strictObject({
     hash: gitSha1Schema,
     treeHash: gitSha1Schema,
     message: z.string(),
@@ -21,13 +21,13 @@ const commit = z.strictObject({
     parents: z.array(gitSha1Schema),
     authoredAt: z.number().int(),
     committedAt: z.number().int(),
-});
-const tree = z.strictObject({
+}));
+const tree = z.lazy(() => z.strictObject({
     name: z.string(),
     mode: z.string(),
     hash: gitSha1Schema,
     type: z.enum(["blob", "tree", "commit"]),
-});
+}));
 const request = z.strictObject({
     service: z.enum(["upload-pack", "receive-pack"]),
     phase: z.enum(["advertise", "exchange"]),
@@ -39,20 +39,18 @@ const response = z.strictObject({
     headers,
     body: bytes,
 });
-const createOptions = z
+const createOptions = z.lazy(() => z
     .strictObject({
     description: z.string().max(8192).optional(),
     defaultBranch: z.string().min(1).max(1024).optional(),
 })
-    .optional();
-const forkOptions = z
-    .strictObject({ description: z.string().max(8192).optional() })
-    .optional();
-const logOptions = z.strictObject({
+    .optional());
+const forkOptions = z.lazy(() => z.strictObject({ description: z.string().max(8192).optional() }).optional());
+const logOptions = z.lazy(() => z.strictObject({
     ref: z.string().min(1).max(1024),
     limit: z.number().int().min(1).max(1000).optional(),
     offset: z.number().int().nonnegative().optional(),
-});
+}));
 /** The native tuple and result grammar shared by the handle and frame entrypoint. */
 export const nativeGitCodecs = {
     create: {

package/dist/git.d.ts

@@ -9,14 +9,14 @@ export type GitRepositoryName = z.output<typeof gitRepositoryNameSchema>;
  * Host-selected repository namespace. Team identity comes from the host;
  * decoding this reference never grants access to either namespace.
  */
-export declare const repositoryRefSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+export declare const repositoryRefSchema: z.ZodLazy<z.ZodDiscriminatedUnion<[z.ZodObject<{
     kind: z.ZodLiteral<"installation">;
     installationId: z.ZodString;
     repository: z.ZodString;
 }, z.core.$strict>, z.ZodObject<{
     kind: z.ZodLiteral<"team-source">;
     repository: z.ZodString;
-}, z.core.$strict>], "kind">;
+}, z.core.$strict>], "kind">>;
 /** Installation-local repository or registered Team source, selected by its host. */
 export type RepositoryRef = z.output<typeof repositoryRefSchema>;
 /** Stable namespace identity, serialized through the canonical repository decoder. */
@@ -84,7 +84,7 @@ export declare const gitWriterSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     }, z.core.$strict>], "kind">>;
 }, z.core.$strict>], "kind">;
 /** The App's question covers the whole push, under host-held attribution. */
-export declare const gitPushQuestionSchema: z.ZodObject<{
+export declare const gitPushQuestionSchema: z.ZodLazy<z.ZodObject<{
     repository: z.ZodString;
     writer: z.ZodObject<{
         kind: z.ZodLiteral<"actor">;
@@ -124,9 +124,9 @@ export declare const gitPushQuestionSchema: z.ZodObject<{
         before: z.ZodString;
         after: z.ZodString;
     }, z.core.$strict>>;
-}, z.core.$strict>;
+}, z.core.$strict>>;
 /** A whole push verdict; refusal messages are shown by ordinary Git clients. */
-export declare const gitPushVerdictSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+export declare const gitPushVerdictSchema: z.ZodLazy<z.ZodDiscriminatedUnion<[z.ZodObject<{
     allowed: z.ZodLiteral<true>;
 }, z.core.$strict>, z.ZodObject<{
     allowed: z.ZodLiteral<false>;
@@ -134,13 +134,13 @@ export declare const gitPushVerdictSchema: z.ZodDiscriminatedUnion<[z.ZodObject<
         ref: z.ZodString;
         message: z.ZodString;
     }, z.core.$strict>>;
-}, z.core.$strict>], "allowed">;
+}, z.core.$strict>], "allowed">>;
 /** Ref question sent only after host grant and Workflow branch admission. */
 export type GitPushQuestion = z.output<typeof gitPushQuestionSchema>;
 /** Explicit permission or bounded per-ref refusal for the whole push. */
 export type GitPushVerdict = z.output<typeof gitPushVerdictSchema>;
 /** One accepted push, with host attribution and no remote or credential. */
-export declare const appGitPushFactSchema: z.ZodObject<{
+export declare const appGitPushFactSchema: z.ZodLazy<z.ZodObject<{
     repository: z.ZodString;
     writer: z.ZodDiscriminatedUnion<[z.ZodObject<{
         kind: z.ZodLiteral<"actor">;
@@ -197,8 +197,8 @@ export declare const appGitPushFactSchema: z.ZodObject<{
         ref: z.ZodString;
         journaled: z.ZodNullable<z.ZodString>;
     }, z.core.$strict>>>;
-    eventId: z.ZodString;
-}, z.core.$strict>;
+    eventId: z.ZodLazy<z.ZodString>;
+}, z.core.$strict>>;
 /** One bounded ref update, shared by push questions and accepted facts. */
 export type GitRefUpdate = z.output<typeof appGitPushFactSchema>["updates"][number];
 /** Host-delivered push fact; retries retain the same event ID. */

package/dist/git.js

@@ -7,7 +7,7 @@ export const gitRepositoryCapability = "git.repository";
  * Host-selected repository namespace. Team identity comes from the host;
  * decoding this reference never grants access to either namespace.
  */
-export const repositoryRefSchema = z.discriminatedUnion("kind", [
+export const repositoryRefSchema = z.lazy(() => z.discriminatedUnion("kind", [
     z.strictObject({
         kind: z.literal("installation"),
         installationId: z.string().min(1).max(256),
@@ -17,7 +17,7 @@ export const repositoryRefSchema = z.discriminatedUnion("kind", [
         kind: z.literal("team-source"),
         repository: gitRepositoryNameSchema,
     }),
-]);
+]));
 /** Stable namespace identity, serialized through the canonical repository decoder. */
 export function repositoryRefKey(repository) {
     return JSON.stringify(repositoryRefSchema.parse(repository));
@@ -55,13 +55,13 @@ export const gitWriterSchema = z.discriminatedUnion("kind", [
     }),
 ]);
 /** The App's question covers the whole push, under host-held attribution. */
-export const gitPushQuestionSchema = z.strictObject({
+export const gitPushQuestionSchema = z.lazy(() => z.strictObject({
     repository: gitRepositoryNameSchema,
     writer: gitWriterSchema.options[0],
     updates: z.array(gitRefUpdateSchema).min(1).max(256),
-});
+}));
 /** A whole push verdict; refusal messages are shown by ordinary Git clients. */
-export const gitPushVerdictSchema = z.discriminatedUnion("allowed", [
+export const gitPushVerdictSchema = z.lazy(() => z.discriminatedUnion("allowed", [
     z.strictObject({ allowed: z.literal(true) }),
     z.strictObject({
         allowed: z.literal(false),
@@ -73,9 +73,9 @@ export const gitPushVerdictSchema = z.discriminatedUnion("allowed", [
             .min(1)
             .max(256),
     }),
-]);
+]));
 /** One accepted push, with host attribution and no remote or credential. */
-export const appGitPushFactSchema = z.strictObject({
+export const appGitPushFactSchema = z.lazy(() => z.strictObject({
     repository: gitRepositoryNameSchema,
     writer: gitWriterSchema,
     updates: z.array(gitRefUpdateSchema).min(1).max(256),
@@ -88,7 +88,7 @@ export const appGitPushFactSchema = z.strictObject({
         .optional(),
     // Host event IDs may include a Computer ID as well as its local event ID.
     eventId: gitPushEventIdSchema,
-});
+}));
 /** Parse a host-admitted fact and invoke its lifecycle handler, preserving rejection. */
 export async function dispatchAppGitPush(lifecycle, raw) {
     const fact = appGitPushFactSchema.parse(raw);

package/dist/host.d.ts

@@ -1,7 +1,7 @@
 import type { AppCommand } from "./commands.js";
 import type { WhistleExecutionOrigin, WhistleJsonValue } from "@fungi.computer/whistle";
 import type { AppContext, AppIdentity, FocusState } from "./lifecycle.js";
-import type { AppNavigationState } from "./window.js";
+import type { AppNavigationActivation, AppNavigationState } from "./window.js";
 import type { AppBrowserAction, AppBrowserActionOutcome, AgentSessionSelection, AppPermissionOutcome, AppPermissionRequest, AppStatusAction, AppStatusItem, FileNavigationInput, ToastInput } from "./ui.js";
 import { AppError } from "./errors.js";
 import { type AppConnectMessage } from "./internal/protocol.js";
@@ -11,6 +11,8 @@ export type AppHost = {
     requestClose(): Promise<boolean>;
     /** Ask the App to go back one step in its own history; `true` when it did. */
     requestBack(): Promise<boolean>;
+    /** Deliver the person's use of a crumb or header command; `true` when the App acted. */
+    activateNavigation(activation: AppNavigationActivation): Promise<boolean>;
     /** Deliver the person's use of a status item; `true` when the App acted. */
     activateStatus(action: AppStatusAction): Promise<boolean>;
     updateContext(fact: AppHostFact<AppContext>): Promise<void>;

package/dist/host.js

@@ -12,7 +12,7 @@ import { disposeRpcValue } from "./internal/capabilities.js";
 import { disconnectHost } from "./internal/disconnect-host.js";
 import { APP_CONNECT_TYPE, APP_PROTOCOL_VERSION, APP_READY_TYPE, } from "./internal/protocol.js";
 import { callRpc, rpcFailure, rpcSuccess, } from "./internal/result.js";
-import { parseBrowserAction, parseChordInvocation, parseCommandResultRpc, parseBackDecisionResult, parseCloseDecisionResult, parseCommand, parseCommandId, parseConnectRequest, parseContextFact, parseFocus, parseAgentSessionSelection, parseLocalHostBootstrap, parseHostLifecycleFact, parseNavigation, parseNavigationState, parseStatusAction, parseStatusItems, parsePermissionRequest, parseReady, parseReservedChordsFact, parseThemeFact, parseToast, parseVoidResult, } from "./internal/schemas.js";
+import { parseBrowserAction, parseChordInvocation, parseCommandResultRpc, parseBackDecisionResult, parseCloseDecisionResult, parseCommand, parseCommandId, parseConnectRequest, parseContextFact, parseFocus, parseAgentSessionSelection, parseLocalHostBootstrap, parseHostLifecycleFact, parseNavigation, parseNavigationActivation, parseNavigationState, parseStatusAction, parseStatusItems, parsePermissionRequest, parseReady, parseReservedChordsFact, parseThemeFact, parseToast, parseVoidResult, } from "./internal/schemas.js";
 import { createTerminalGate, } from "./internal/terminal-gate.js";
 /** One pending or live mount belongs to each iframe WindowProxy. */
 const liveMounts = new WeakMap();
@@ -639,6 +639,10 @@ function createHost(options) {
             assertLive();
             return await callRpc(options.client.requestBack(), parseBackDecisionResult);
         },
+        activateNavigation: async (activation) => {
+            assertLive();
+            return await callRpc(options.client.activateNavigation(parseNavigationActivation(activation)), parseBackDecisionResult);
+        },
         activateStatus: async (action) => {
             assertLive();
             return await callRpc(options.client.activateStatus(parseStatusAction(action)), parseBackDecisionResult);