@fungi.computer/oyster 0.0.1 → 0.1.0

package/dist/release.d.ts

@@ -9,6 +9,17 @@ export type ArtifactStore = Readonly<{
     /** Store bytes under `artifactRef`; the caller has verified the digest. */
     put: (artifactRef: ArtifactRef, bytes: Uint8Array) => Promise<void>;
 }>;
+/** What a store knows of one object without reading it. */
+export type ArtifactHead = Readonly<{
+    byteLength: number;
+    /** The digest the store verified when it took the bytes, if it did. */
+    digest: Sha256Digest | null;
+}>;
+/** A store that can describe an object without reading its bytes. */
+export type ArtifactHeads = Readonly<{
+    /** Describe the object at `artifactRef`, or `null` when absent. */
+    head: (artifactRef: ArtifactRef) => Promise<ArtifactHead | null>;
+}>;
 /** Why a Release could not be read; the host maps it to an HTTP refusal. */
 export declare class ReleaseError extends Error {
     readonly code: "artifact_missing" | "digest_mismatch" | "invalid_release" | "asset_missing";

package/dist/release.js

@@ -79,8 +79,11 @@ readAssets = true) {
             catch (cause) {
                 throw new ReleaseError("invalid_release", "Invalid assets", { cause });
             }
+            // One asset at a time: a Release's assets together can exceed an
+            // isolate's memory, each alone is bounded by its policy.
             if (readAssets)
-                await Promise.all(assets.assets.map((asset) => readVerified(store, asset.artifactRef, asset.digest)));
+                for (const asset of assets.assets)
+                    await readVerified(store, asset.artifactRef, asset.digest);
             ui = { kind: "assets", build: assets };
         }
         else

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

@@ -132,13 +132,7 @@ export declare const appRoleSelectionSchema: z.ZodObject<{
     surfaceId: z.ZodNullable<z.ZodString>;
     chosen: z.ZodBoolean;
 }, z.core.$strict>;
-declare const appComputerOperationSchema: z.ZodEnum<{
-    "computer.list": "computer.list";
-    "computer.readFile": "computer.readFile";
-    "computer.writeFile": "computer.writeFile";
-    "computer.execute": "computer.execute";
-}>;
-export type AppComputerOperation = z.output<typeof appComputerOperationSchema>;
+/** App Computer permissions limited to selected Computers or the Team's Computers. */
 export declare const appComputerPermissionSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     kind: z.ZodLiteral<"selected-computers">;
     computers: z.ZodArray<z.ZodObject<{
@@ -159,7 +153,13 @@ export declare const appComputerPermissionSchema: z.ZodDiscriminatedUnion<[z.Zod
         "computer.execute": "computer.execute";
     }>>;
 }, z.core.$strict>], "kind">;
+/** One operation an App may request for a Computer. */
+export type AppComputerOperation = Extract<z.output<typeof appComputerPermissionSchema>, {
+    kind: "all-team-computers";
+}>["operations"][number];
+/** Decoded Computer permission scope attached to an App directory entry. */
 export type AppComputerPermission = z.output<typeof appComputerPermissionSchema>;
+/** Agent directory and session operations an App may request from its host. */
 export declare const appAgentPermissionSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     kind: z.ZodLiteral<"all-team-agents">;
     directoryOperations: z.ZodArray<z.ZodEnum<{
@@ -184,17 +184,22 @@ export declare const appAgentPermissionSchema: z.ZodDiscriminatedUnion<[z.ZodObj
         }>>;
     }, z.core.$strict>>;
 }, z.core.$strict>], "kind">;
+/** Decoded Agent permission scope attached to an App directory entry. */
 export type AppAgentPermission = z.output<typeof appAgentPermissionSchema>;
+/** Whether an App may use language-model and media generation services. */
 export declare const appGenerationPermissionsSchema: z.ZodObject<{
     llm: z.ZodBoolean;
     media: z.ZodBoolean;
 }, z.core.$strict>;
+/** Decoded generation permissions attached to an App directory entry. */
 export type AppGenerationPermissions = z.output<typeof appGenerationPermissionsSchema>;
+/** Whether an App may browse, buy, or install free marketplace entries. */
 export declare const appMarketplacePermissionsSchema: z.ZodObject<{
     browse: z.ZodBoolean;
     purchase: z.ZodBoolean;
     installFree: z.ZodBoolean;
 }, z.core.$strict>;
+/** Decoded marketplace permissions attached to an App directory entry. */
 export type AppMarketplacePermissions = z.output<typeof appMarketplacePermissionsSchema>;
 /**
  * A host's Team App directory with its permission projection, parsed strictly
@@ -357,6 +362,7 @@ export declare const appDirectoryResponseSchema: z.ZodObject<{
         chosen: z.ZodBoolean;
     }, z.core.$strict>>;
 }, z.core.$strict>;
+/** The host-resolved Team App directory and its permission projections. */
 export type AppDirectory = z.output<typeof appDirectoryResponseSchema>;
 /** Read-only catalog metadata for one App, without host-specific role policy. */
 export declare const appCatalogEntrySchema: z.ZodObject<{
@@ -534,4 +540,3 @@ export declare const appCatalogBrokerResultSchema: z.ZodUnion<readonly [z.ZodObj
 }, z.core.$strict>, z.ZodObject<{
     error: z.ZodString;
 }, z.core.$strict>]>;
-export {};

package/dist/shell/app-directory.js

@@ -80,6 +80,7 @@ const allTeamComputersPermissionSchema = z.strictObject({
     kind: z.literal("all-team-computers"),
     operations: z.array(appComputerOperationSchema),
 });
+/** App Computer permissions limited to selected Computers or the Team's Computers. */
 export const appComputerPermissionSchema = z.discriminatedUnion("kind", [
     selectedComputerPermissionSchema,
     allTeamComputersPermissionSchema,
@@ -90,6 +91,7 @@ const agentSessionOperationSchema = z.enum([
     "agent.send",
     "agent.manage",
 ]);
+/** Agent directory and session operations an App may request from its host. */
 export const appAgentPermissionSchema = z.discriminatedUnion("kind", [
     z.strictObject({
         kind: z.literal("all-team-agents"),
@@ -105,10 +107,12 @@ export const appAgentPermissionSchema = z.discriminatedUnion("kind", [
         })),
     }),
 ]);
+/** Whether an App may use language-model and media generation services. */
 export const appGenerationPermissionsSchema = z.strictObject({
     llm: z.boolean(),
     media: z.boolean(),
 });
+/** Whether an App may browse, buy, or install free marketplace entries. */
 export const appMarketplacePermissionsSchema = z.strictObject({
     browse: z.boolean(),
     purchase: z.boolean(),

package/dist/shell/shell-module.d.ts

@@ -1,6 +1,7 @@
 import type { AppStorage } from "@fungi.computer/agar/storage";
 import type { WhistleJsonValue } from "@fungi.computer/whistle";
 import type { TeamWorkbenchHostHandle } from "./workbench-contract.js";
+import type { WorkbenchHostControls } from "./workbench-host-types.js";
 /**
  * What a host hands the shell a Team picked. The host composes that shell into
  * its own top-level document, so it runs with the host's escalated
@@ -20,12 +21,35 @@ export type ShellMountInput = Readonly<{
  * function that removes it again. The shell loads its own code and styles.
  */
 export type MountShell = (root: HTMLElement, input: ShellMountInput) => Promise<() => void>;
+/**
+ * Settings a shell renders for a host that has none of its own, such as a
+ * standalone Oyster: the shell draws them into `root`, and the host hands
+ * `controls` to its workbench so Apps and the dashboard can open them.
+ */
+export type ShellPlatformControls = Readonly<{
+    controls: WorkbenchHostControls;
+    /** A child App suggested desktop Settings for one of its surfaces. */
+    suggestDesktopSettings(surfaceId: string): void;
+    /** Remove the rendered Settings. */
+    dispose(): void;
+}>;
+/** Render the shell's own Settings into `root` for the host at `teamId`. */
+export type MountPlatformControls = (root: HTMLElement, input: Readonly<{
+    teamId: string;
+}>) => Promise<ShellPlatformControls>;
+/** What a host gets from a picked shell Release's module. */
+export type ShellModule = Readonly<{
+    mountShell: MountShell;
+    /** Absent when the shell renders no Settings of its own. */
+    mountPlatformControls: MountPlatformControls | null;
+}>;
 /** The picked shell's module could not be loaded or does not fit the contract. */
 export declare class ShellModuleError extends Error {
     readonly name = "ShellModuleError";
 }
 /**
  * Import the picked shell Release's module from the host's own origin and
- * check that it exports `mountShell`. The host never bundles a shell.
+ * check that it exports `mountShell`, and `mountPlatformControls` when it
+ * offers its own Settings. The host never bundles a shell.
  */
-export declare function importShellModule(moduleUrl: URL, hostOrigin: string): Promise<MountShell>;
+export declare function importShellModule(moduleUrl: URL, hostOrigin: string): Promise<ShellModule>;

package/dist/shell/shell-module.js

@@ -1,4 +1,5 @@
 import * as z from "zod";
+const unsubscribe = () => z.function({ input: [], output: z.void() });
 /** The module namespace a shell Release must export; built on first use,
  * since only a browser has `HTMLElement`. */
 const shellModuleSchema = () => z.object({
@@ -7,6 +8,50 @@ const shellModuleSchema = () => z.object({
         input: [z.instanceof(HTMLElement), z.unknown()],
         output: z.promise(z.function({ input: [], output: z.void() })),
     }),
+    mountPlatformControls: z
+        .function({
+        input: [
+            z.instanceof(HTMLElement),
+            z.object({ teamId: z.string() }).readonly(),
+        ],
+        output: z.promise(z.object({
+            controls: z.object({
+                sections: z.array(z.string()).readonly().optional(),
+                // The host passes the workbench's own values; the shell
+                // parses what it reads.
+                parseSettings: z.function({
+                    input: [z.unknown()],
+                    output: z.json(),
+                }),
+                openSettings: z.function({
+                    input: [z.unknown(), z.object({ restoreFocus: z.boolean() })],
+                    output: z.void(),
+                }),
+                subscribeSettingsClosed: z.function({
+                    input: [unsubscribe()],
+                    output: unsubscribe(),
+                }),
+                subscribeChanges: z.function({
+                    input: [unsubscribe()],
+                    output: unsubscribe(),
+                }),
+                attachDesktopSettings: z.function({
+                    input: [z.unknown()],
+                    output: unsubscribe(),
+                }),
+                requestAppAccess: z.function({
+                    input: [z.unknown(), z.unknown()],
+                    output: z.promise(z.enum(["granted", "declined", "customize"])),
+                }),
+            }),
+            suggestDesktopSettings: z.function({
+                input: [z.string()],
+                output: z.void(),
+            }),
+            dispose: unsubscribe(),
+        })),
+    })
+        .optional(),
 });
 /** The picked shell's module could not be loaded or does not fit the contract. */
 export class ShellModuleError extends Error {
@@ -14,7 +59,8 @@ export class ShellModuleError extends Error {
 }
 /**
  * Import the picked shell Release's module from the host's own origin and
- * check that it exports `mountShell`. The host never bundles a shell.
+ * check that it exports `mountShell`, and `mountPlatformControls` when it
+ * offers its own Settings. The host never bundles a shell.
  */
 export async function importShellModule(moduleUrl, hostOrigin) {
     if (moduleUrl.origin !== hostOrigin || moduleUrl.hash !== "")
@@ -33,5 +79,8 @@ export async function importShellModule(moduleUrl, hostOrigin) {
         throw new ShellModuleError("The picked shell does not export mountShell", {
             cause: decoded.error,
         });
-    return decoded.data.mountShell;
+    return {
+        mountShell: decoded.data.mountShell,
+        mountPlatformControls: decoded.data.mountPlatformControls ?? null,
+    };
 }

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.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.ZodObject<{
+            requestId: z.ZodString;
+            address: 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.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.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/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";