@fungi.computer/oyster 0.0.1 → 0.2.0

package/dist/shell/workbench-directory.d.ts

@@ -0,0 +1,332 @@
+import * as z from "zod";
+/** Desktop metadata shared by hosts; hosted administration stays in Settings. */
+export declare const workbenchDirectorySchema: z.ZodPipe<z.ZodObject<{
+    apps: z.ZodArray<z.ZodObject<{
+        address: z.ZodLazy<z.ZodUnion<readonly [z.ZodObject<{
+            kind: z.ZodLiteral<"default">;
+            appId: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"installation">;
+            installationId: z.ZodString;
+        }, z.core.$strict>]>>;
+        installationId: z.ZodNullable<z.ZodString>;
+        surfaceId: z.ZodString;
+        appId: z.ZodString;
+        displayName: z.ZodOptional<z.ZodString>;
+        icon: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        releaseId: z.ZodNullable<z.ZodString>;
+        authorityVersion: z.ZodNumber;
+        enforcement: z.ZodNullable<z.ZodLazy<z.ZodObject<{
+            requestId: z.ZodString;
+            address: z.ZodLazy<z.ZodUnion<readonly [z.ZodObject<{
+                kind: z.ZodLiteral<"default">;
+                appId: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"installation">;
+                installationId: z.ZodString;
+            }, z.core.$strict>]>>;
+            authorityVersion: z.ZodNumber;
+            state: z.ZodEnum<{
+                unaffected: "unaffected";
+                pending: "pending";
+                applied: "applied";
+                expired: "expired";
+            }>;
+            outstanding: z.ZodNumber;
+        }, z.core.$strict>>>;
+        handlers: z.ZodArray<z.ZodLiteral<"file.open">>;
+        roles: z.ZodArray<z.ZodString>;
+        declaredCapabilities: z.ZodArray<z.ZodString>;
+        calls: z.ZodOptional<z.ZodPipe<z.ZodUnknown, z.ZodTransform<readonly {
+            readonly appId: string;
+            readonly methods: readonly string[];
+        }[], unknown>>>;
+        commands: z.ZodPipe<z.ZodArray<z.ZodUnknown>, z.ZodTransform<Readonly<{
+            id: string;
+            title: string;
+            category: string;
+            description?: string | undefined;
+            sigil?: string | undefined;
+            projections?: Readonly<{
+                bindings?: (Readonly<{
+                    order?: number | undefined;
+                }> & Readonly<{
+                    values: readonly string[];
+                }>) | undefined;
+                agent?: (Readonly<{
+                    order?: number | undefined;
+                }> & Readonly<{
+                    keybind?: string | undefined;
+                }>) | undefined;
+                help?: Readonly<{
+                    order?: number | undefined;
+                }> | undefined;
+                menu?: Readonly<{
+                    order?: number | undefined;
+                }> | undefined;
+                palette?: Readonly<{
+                    order?: number | undefined;
+                }> | undefined;
+                slash?: (Readonly<{
+                    order?: number | undefined;
+                }> & Readonly<{
+                    aliases: readonly string[];
+                }>) | undefined;
+            }> | undefined;
+        }>[], unknown[]>>;
+        gills: z.ZodPipe<z.ZodArray<z.ZodUnknown>, z.ZodTransform<import("./app-directory.js").AppDirectoryGill[], unknown[]>>;
+        availability: z.ZodEnum<{
+            available: "available";
+            unavailable: "unavailable";
+        }>;
+        surface: z.ZodNullable<z.ZodObject<{
+            stableRoute: z.ZodString;
+        }, z.core.$strict>>;
+        surfacePath: z.ZodString;
+        computer: z.ZodOptional<z.ZodObject<{
+            computerId: z.ZodString;
+            name: z.ZodString;
+        }, z.core.$strip>>;
+        computerPermission: z.ZodOptional<z.ZodNullable<z.ZodDiscriminatedUnion<[z.ZodLazy<z.ZodObject<{
+            kind: z.ZodLiteral<"selected-computers">;
+            computers: z.ZodArray<z.ZodObject<{
+                computerId: z.ZodString;
+                operations: z.ZodArray<z.ZodEnum<{
+                    "computer.list": "computer.list";
+                    "computer.readFile": "computer.readFile";
+                    "computer.writeFile": "computer.writeFile";
+                    "computer.execute": "computer.execute";
+                }>>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>, z.ZodLazy<z.ZodObject<{
+            kind: z.ZodLiteral<"all-team-computers">;
+            operations: z.ZodArray<z.ZodEnum<{
+                "computer.list": "computer.list";
+                "computer.readFile": "computer.readFile";
+                "computer.writeFile": "computer.writeFile";
+                "computer.execute": "computer.execute";
+            }>>;
+        }, z.core.$strict>>], "kind">>>;
+    }, z.core.$strip>>;
+    computer: z.ZodOptional<z.ZodObject<{
+        computerId: z.ZodString;
+        name: z.ZodString;
+    }, z.core.$strip>>;
+    roles: z.ZodRecord<z.ZodString, z.ZodObject<{
+        surfaceId: z.ZodNullable<z.ZodString>;
+        chosen: z.ZodBoolean;
+    }, z.core.$strict>>;
+    needsUpdate: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        installationId: z.ZodNullable<z.ZodString>;
+        appId: z.ZodNullable<z.ZodString>;
+        displayName: z.ZodString;
+    }, z.core.$strict>>>;
+}, z.core.$strip>, z.ZodTransform<{
+    apps: {
+        address: {
+            kind: "default";
+            appId: string;
+        } | {
+            kind: "installation";
+            installationId: string;
+        };
+        installationId: string | null;
+        surfaceId: string;
+        appId: string;
+        releaseId: string | null;
+        authorityVersion: number;
+        enforcement: {
+            requestId: string;
+            address: {
+                kind: "default";
+                appId: string;
+            } | {
+                kind: "installation";
+                installationId: string;
+            };
+            authorityVersion: number;
+            state: "unaffected" | "pending" | "applied" | "expired";
+            outstanding: number;
+        } | null;
+        handlers: "file.open"[];
+        roles: string[];
+        declaredCapabilities: string[];
+        commands: Readonly<{
+            id: string;
+            title: string;
+            category: string;
+            description?: string | undefined;
+            sigil?: string | undefined;
+            projections?: Readonly<{
+                bindings?: (Readonly<{
+                    order?: number | undefined;
+                }> & Readonly<{
+                    values: readonly string[];
+                }>) | undefined;
+                agent?: (Readonly<{
+                    order?: number | undefined;
+                }> & Readonly<{
+                    keybind?: string | undefined;
+                }>) | undefined;
+                help?: Readonly<{
+                    order?: number | undefined;
+                }> | undefined;
+                menu?: Readonly<{
+                    order?: number | undefined;
+                }> | undefined;
+                palette?: Readonly<{
+                    order?: number | undefined;
+                }> | undefined;
+                slash?: (Readonly<{
+                    order?: number | undefined;
+                }> & Readonly<{
+                    aliases: readonly string[];
+                }>) | undefined;
+            }> | undefined;
+        }>[];
+        gills: import("./app-directory.js").AppDirectoryGill[];
+        availability: "available" | "unavailable";
+        surface: {
+            stableRoute: string;
+        } | null;
+        surfacePath: string;
+        displayName?: string | undefined;
+        icon?: string | null | undefined;
+        calls?: readonly {
+            readonly appId: string;
+            readonly methods: readonly string[];
+        }[] | undefined;
+        computer?: {
+            computerId: string;
+            name: string;
+        } | undefined;
+        computerPermission?: {
+            kind: "selected-computers";
+            computers: {
+                computerId: string;
+                operations: ("computer.list" | "computer.readFile" | "computer.writeFile" | "computer.execute")[];
+            }[];
+        } | {
+            kind: "all-team-computers";
+            operations: ("computer.list" | "computer.readFile" | "computer.writeFile" | "computer.execute")[];
+        } | null | undefined;
+    }[];
+    roles: Record<string, {
+        surfaceId: string | null;
+        chosen: boolean;
+    }>;
+    computer?: {
+        computerId: string;
+        name: string;
+    } | undefined;
+    needsUpdate?: {
+        installationId: string | null;
+        appId: string | null;
+        displayName: string;
+    }[] | undefined;
+}, {
+    apps: {
+        address: {
+            kind: "default";
+            appId: string;
+        } | {
+            kind: "installation";
+            installationId: string;
+        };
+        installationId: string | null;
+        surfaceId: string;
+        appId: string;
+        releaseId: string | null;
+        authorityVersion: number;
+        enforcement: {
+            requestId: string;
+            address: {
+                kind: "default";
+                appId: string;
+            } | {
+                kind: "installation";
+                installationId: string;
+            };
+            authorityVersion: number;
+            state: "unaffected" | "pending" | "applied" | "expired";
+            outstanding: number;
+        } | null;
+        handlers: "file.open"[];
+        roles: string[];
+        declaredCapabilities: string[];
+        commands: Readonly<{
+            id: string;
+            title: string;
+            category: string;
+            description?: string | undefined;
+            sigil?: string | undefined;
+            projections?: Readonly<{
+                bindings?: (Readonly<{
+                    order?: number | undefined;
+                }> & Readonly<{
+                    values: readonly string[];
+                }>) | undefined;
+                agent?: (Readonly<{
+                    order?: number | undefined;
+                }> & Readonly<{
+                    keybind?: string | undefined;
+                }>) | undefined;
+                help?: Readonly<{
+                    order?: number | undefined;
+                }> | undefined;
+                menu?: Readonly<{
+                    order?: number | undefined;
+                }> | undefined;
+                palette?: Readonly<{
+                    order?: number | undefined;
+                }> | undefined;
+                slash?: (Readonly<{
+                    order?: number | undefined;
+                }> & Readonly<{
+                    aliases: readonly string[];
+                }>) | undefined;
+            }> | undefined;
+        }>[];
+        gills: import("./app-directory.js").AppDirectoryGill[];
+        availability: "available" | "unavailable";
+        surface: {
+            stableRoute: string;
+        } | null;
+        surfacePath: string;
+        displayName?: string | undefined;
+        icon?: string | null | undefined;
+        calls?: readonly {
+            readonly appId: string;
+            readonly methods: readonly string[];
+        }[] | undefined;
+        computer?: {
+            computerId: string;
+            name: string;
+        } | undefined;
+        computerPermission?: {
+            kind: "selected-computers";
+            computers: {
+                computerId: string;
+                operations: ("computer.list" | "computer.readFile" | "computer.writeFile" | "computer.execute")[];
+            }[];
+        } | {
+            kind: "all-team-computers";
+            operations: ("computer.list" | "computer.readFile" | "computer.writeFile" | "computer.execute")[];
+        } | null | undefined;
+    }[];
+    roles: Record<string, {
+        surfaceId: string | null;
+        chosen: boolean;
+    }>;
+    computer?: {
+        computerId: string;
+        name: string;
+    } | undefined;
+    needsUpdate?: {
+        installationId: string | null;
+        appId: string | null;
+        displayName: string;
+    }[] | undefined;
+}>>;
+/** One host's current desktop rows and actual role selections. */
+export type WorkbenchDirectory = z.output<typeof workbenchDirectorySchema>;

package/dist/shell/workbench-directory.js

@@ -0,0 +1,35 @@
+import * as z from "zod";
+import { appDirectoryEntrySchema, appRoleSelectionSchema, appComputerPermissionSchema, } from "./app-directory.js";
+import { teamComputerSchema } from "./workbench-model.js";
+const computerChoiceSchema = teamComputerSchema
+    .pick({ computerId: true, name: true })
+    .strip();
+/** Desktop metadata shared by hosts; hosted administration stays in Settings. */
+export const workbenchDirectorySchema = z
+    .object({
+    apps: z.array(appDirectoryEntrySchema
+        .extend({
+        computer: computerChoiceSchema.optional(),
+        computerPermission: appComputerPermissionSchema.nullable().optional(),
+    })
+        .strip()),
+    /** Fixed standalone context, not a Team Computer permission or capability grant. */
+    computer: computerChoiceSchema.optional(),
+    roles: z.record(z.string().min(1), appRoleSelectionSchema),
+    needsUpdate: z
+        .array(z.strictObject({
+        installationId: z.string().min(1).nullable(),
+        appId: z.string().min(1).nullable(),
+        displayName: z.string().min(1),
+    }))
+        .optional(),
+})
+    .transform((directory) => directory.computer === undefined
+    ? directory
+    : {
+        ...directory,
+        apps: directory.apps.map((app) => ({
+            ...app,
+            computer: directory.computer,
+        })),
+    });

package/dist/shell/workbench-host-types.d.ts

@@ -9,7 +9,7 @@ export type WorkbenchResolvedChild = Readonly<{
     title?: string;
 }>;
 /** The host's real mounted App; selection and lease replacement stay with it. */
-export type WorkbenchChildSurface = Pick<WorkbenchChildHandle, "setVisibility" | "requestClose" | "requestBack" | "activateStatus"> & {
+export type WorkbenchChildSurface = Pick<WorkbenchChildHandle, "setVisibility" | "requestClose" | "requestBack" | "activateStatus" | "activateNavigation"> & {
     /** Release the mounted child or host-owned observations. */
     dispose(): void;
     /** Replace the host-admitted selection while retaining the child document. */

package/dist/shell/workbench-host.js

@@ -109,6 +109,11 @@ class MountedChildHandle {
         // The shell relays the person's click; parse it at the host's edge.
         return this.surface.activateStatus(parseAppStatusAction(action));
     }
+    async activateNavigation(activation) {
+        if (this.#disposed)
+            return false;
+        return this.surface.activateNavigation(activation);
+    }
     async invokeCommand(commandId, input) {
         const invoke = this.commands.invoke;
         if (this.#disposed || invoke === undefined)

package/dist/shell/workbench-model.d.ts

@@ -1,6 +1,6 @@
 import * as z from "zod";
 import * as Schema from "effect/Schema";
-import type { AppCommand, AppOpenRequest, FileNavigationInput, AppNavigationState, AppStatusAction, AppStatusItem } from "@fungi.computer/agar";
+import type { AppCommand, AppOpenRequest, FileNavigationInput, AppNavigationActivation, AppNavigationState, AppStatusAction, AppStatusItem } from "@fungi.computer/agar";
 import type { AppOpenInput, AppRoleChoice } from "@fungi.computer/agar/apps";
 import type { WhistleExecutionOrigin, WhistleJsonValue } from "@fungi.computer/whistle";
 /** A request to resolve and mount one child App, by its own identity. */
@@ -68,6 +68,8 @@ export type WorkbenchChildHandle = {
     requestBack(): Promise<boolean>;
     /** Deliver the person's use of a child's status item; `true` when it acted. */
     activateStatus(action: AppStatusAction): Promise<boolean>;
+    /** Deliver the person's use of a child's crumb or header command; `true` when it acted. */
+    activateNavigation(activation: AppNavigationActivation): Promise<boolean>;
     /** Run one of the child's currently presented commands. */
     invokeCommand(commandId: string, input: WorkbenchCommandInvocation): Promise<WhistleJsonValue | undefined>;
     /** Release the child mount and its resources. */

package/dist/source/index.d.ts

@@ -1,11 +1,10 @@
-/** App source seed receipts and the fork algorithm, owned generically here;
- * the Publisher supplies D1 adapters and the retained Git admission
- * transport. The Node-only template writer (`memfs` + `isomorphic-git`) is
- * deliberately not re-exported here: it would drag that dependency into
- * every Worker bundle that only needs the fork/provenance reads below (team
- * rail's RPC surface has no use for it). Import it from
- * `@fungi.computer/oyster/source/template-write` instead. */
+/** App source seed receipts, seed claims and the fork algorithm, owned
+ * generically here; the Publisher supplies D1 adapters and the retained Git
+ * admission transport. The operator's Node-only template push (it runs the
+ * `git` executable) is deliberately not re-exported here, so Worker bundles
+ * never import it: use `@fungi.computer/oyster/source/template-push`. */
 export { templateRepositoryForApp } from "./template-repository.js";
 export { seedReceiptInputSchema, sameReceipt, type PublisherTemplateSeedReceipt, type PublisherTemplateSeedReceipts, } from "./seed-receipt.js";
 export { readTeamAppSeedProvenance, privateTeamBuildSource, TeamAppSourceError, } from "./team-source.js";
+export { parseTemplateSeedClaim, recordTemplateSeed, templateSeedClaimSchema, TEMPLATE_SEED_CLAIM_MAX_BYTES, type TemplateSeedClaim, } from "./template-seed.js";
 export { forkAppSource, type AppSourceForkResult } from "./fork.js";

package/dist/source/index.js

@@ -1,11 +1,10 @@
-/** App source seed receipts and the fork algorithm, owned generically here;
- * the Publisher supplies D1 adapters and the retained Git admission
- * transport. The Node-only template writer (`memfs` + `isomorphic-git`) is
- * deliberately not re-exported here: it would drag that dependency into
- * every Worker bundle that only needs the fork/provenance reads below (team
- * rail's RPC surface has no use for it). Import it from
- * `@fungi.computer/oyster/source/template-write` instead. */
+/** App source seed receipts, seed claims and the fork algorithm, owned
+ * generically here; the Publisher supplies D1 adapters and the retained Git
+ * admission transport. The operator's Node-only template push (it runs the
+ * `git` executable) is deliberately not re-exported here, so Worker bundles
+ * never import it: use `@fungi.computer/oyster/source/template-push`. */
 export { templateRepositoryForApp } from "./template-repository.js";
 export { seedReceiptInputSchema, sameReceipt, } from "./seed-receipt.js";
 export { readTeamAppSeedProvenance, privateTeamBuildSource, TeamAppSourceError, } from "./team-source.js";
+export { parseTemplateSeedClaim, recordTemplateSeed, templateSeedClaimSchema, TEMPLATE_SEED_CLAIM_MAX_BYTES, } from "./template-seed.js";
 export { forkAppSource } from "./fork.js";

package/dist/source/template-push.d.ts

@@ -0,0 +1,33 @@
+import { type SourceRevision } from "@fungi.computer/puffball";
+/** One projected source tree, as `createFirstPartyAppSourceDistribution` returns it. */
+export type TemplateSourceFiles = readonly Readonly<{
+    path: string;
+    contents: Uint8Array;
+}>[];
+/** What one template push did: the template's `main` now names `seedRevision`. */
+export type TemplatePushResult = Readonly<{
+    seedRevision: SourceRevision;
+    /** False when `main` already held this exact tree (an exact retry). */
+    pushed: boolean;
+}>;
+/**
+ * Commit one projected App source tree onto its template repository's `main`
+ * with ordinary Git, and push it there over smart HTTP.
+ *
+ * The tree holds exactly the given bytes (no attributes or filters), each a
+ * regular non-executable file. The first seed is a parentless commit; a later
+ * different tree is an ordinary fast-forward on the current head; an exact
+ * retry pushes nothing and answers the current head. Nothing is forced. The
+ * `headers` authenticate every request and reach Git only through its config
+ * environment.
+ */
+export declare function pushTemplateSource(input: Readonly<{
+    appId: string;
+    /** The upstream commit the tree was projected from (`git:<sha>`). */
+    sourceRevision: string;
+    files: TemplateSourceFiles;
+    /** The template repository's smart-HTTP URL, without credentials. */
+    remote: string;
+    headers: Readonly<Record<string, string>>;
+    signal?: AbortSignal;
+}>): Promise<TemplatePushResult>;