@fungi.computer/oyster 0.0.1 → 0.2.0

package/dist/apps/installation.d.ts

@@ -6,7 +6,7 @@ import type { CapabilityDescriptor } from "../capability-descriptor.js";
 /** Reuse the owning Effect codec at a JSON/storage boundary. */
 export declare function ownerCodec<A, I>(schema: Schema.Codec<A, I>): z.ZodPipe<z.ZodUnknown, z.ZodTransform<Awaited<A>, unknown>>;
 /** Installation names cannot contain the tenant separator. */
-export declare const installationIdSchema: z.ZodString;
+export declare const installationIdSchema: z.ZodLazy<z.ZodString>;
 export type ResourceRef = Exclude<ApprovedGrant["resources"], "tenant-scope">[number];
 /**
  * Consent approves capabilities, with explicit operation and resource ceilings.
@@ -21,13 +21,13 @@ export type ResourceRef = Exclude<ApprovedGrant["resources"], "tenant-scope">[nu
  * Exact operation rows are enforced for capability routes and backend bindings.
  */
 export declare const approvedGrantSchema: z.ZodReadonly<z.ZodObject<{
-    capability: z.ZodPipe<z.ZodUnknown, z.ZodTransform<"agent.list" | "agent.manage" | "agent.rename" | "agent.toolPolicy" | "agent.read" | "agent.send" | "computer.list" | "computer.readFile" | "computer.writeFile" | "computer.execute" | "llm.generation" | "media.generation" | "games:servers" | "git.repository" | "apps.open" | "apps.call" | "app.storage" | "app.events.emit" | "team.workbenchHost" | "marketplace.browse" | "marketplace.purchase" | "workflow.run" | "workflow.publish" | "workflow.arm" | "world" | "channels.read" | "channels.personal.manage", unknown>>;
+    capability: z.ZodPipe<z.ZodUnknown, z.ZodTransform<"agent.list" | "agent.manage" | "agent.rename" | "agent.avatar" | "agent.toolPolicy" | "agent.read" | "agent.send" | "computer.list" | "computer.readFile" | "computer.writeFile" | "computer.execute" | "llm.generation" | "media.generation" | "games:servers" | "git.repository" | "apps.open" | "apps.call" | "app.storage" | "app.events.emit" | "team.workbenchHost" | "marketplace.browse" | "marketplace.purchase" | "workflow.run" | "workflow.publish" | "workflow.arm" | "world" | "channels.read" | "channels.personal.manage", unknown>>;
     capabilityApproved: z.ZodLiteral<true>;
-    operations: z.ZodReadonly<z.ZodArray<z.ZodString>>;
-    resources: z.ZodUnion<readonly [z.ZodLiteral<"tenant-scope">, z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+    operations: z.ZodLazy<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+    resources: z.ZodUnion<readonly [z.ZodLiteral<"tenant-scope">, z.ZodReadonly<z.ZodArray<z.ZodLazy<z.ZodReadonly<z.ZodObject<{
         kind: z.ZodString;
         id: z.ZodString;
-    }, z.core.$strict>>>>]>;
+    }, z.core.$strict>>>>>]>;
 }, z.core.$strict>>;
 export type ApprovedGrant = Readonly<z.output<typeof approvedGrantSchema>>;
 export type GrantRequest = Extract<InstallationCommand, {
@@ -35,7 +35,7 @@ export type GrantRequest = Extract<InstallationCommand, {
 }>["grants"];
 export type Approval = NonNullable<Installation["approval"]>;
 /** Immutable operation facts derived from descriptor methods and the binding registry. */
-export declare const declaredOperationsSchema: z.ZodObject<{
+export declare const declaredOperationsSchema: z.ZodLazy<z.ZodObject<{
     artifactDigest: z.ZodPipe<z.ZodUnknown, z.ZodTransform<import("@fungi.computer/puffball").Sha256Digest, unknown>>;
     digest: z.ZodPipe<z.ZodUnknown, z.ZodTransform<import("@fungi.computer/puffball").Sha256Digest, unknown>>;
     anonymousMethods: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
@@ -43,10 +43,10 @@ export declare const declaredOperationsSchema: z.ZodObject<{
         digest: z.ZodPipe<z.ZodUnknown, z.ZodTransform<import("@fungi.computer/puffball").Sha256Digest, unknown>>;
     }, z.core.$strict>>>>;
     capabilities: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
-        capability: z.ZodPipe<z.ZodUnknown, z.ZodTransform<"agent.list" | "agent.manage" | "agent.rename" | "agent.toolPolicy" | "agent.read" | "agent.send" | "computer.list" | "computer.readFile" | "computer.writeFile" | "computer.execute" | "llm.generation" | "media.generation" | "games:servers" | "git.repository" | "apps.open" | "apps.call" | "app.storage" | "app.events.emit" | "team.workbenchHost" | "marketplace.browse" | "marketplace.purchase" | "workflow.run" | "workflow.publish" | "workflow.arm" | "world" | "channels.read" | "channels.personal.manage", unknown>>;
-        operations: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+        capability: z.ZodPipe<z.ZodUnknown, z.ZodTransform<"agent.list" | "agent.manage" | "agent.rename" | "agent.avatar" | "agent.toolPolicy" | "agent.read" | "agent.send" | "computer.list" | "computer.readFile" | "computer.writeFile" | "computer.execute" | "llm.generation" | "media.generation" | "games:servers" | "git.repository" | "apps.open" | "apps.call" | "app.storage" | "app.events.emit" | "team.workbenchHost" | "marketplace.browse" | "marketplace.purchase" | "workflow.run" | "workflow.publish" | "workflow.arm" | "world" | "channels.read" | "channels.personal.manage", unknown>>;
+        operations: z.ZodLazy<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
     }, z.core.$strict>>>>;
-}, z.core.$strict>;
+}, z.core.$strict>>;
 export type DeclaredOperations = Readonly<z.output<typeof declaredOperationsSchema>>;
 /** Use the existing adapter's permission and methods; hosts author no operation lists. */
 export type CapabilityOperationDescriptor = Pick<CapabilityDescriptor, "id" | "methods"> & Readonly<{
@@ -54,7 +54,7 @@ export type CapabilityOperationDescriptor = Pick<CapabilityDescriptor, "id" | "m
 }>;
 /** Resolved immutable Release plus host-owned installation and approval state. */
 export declare const installationSchema: z.ZodObject<{
-    installationId: z.ZodString;
+    installationId: z.ZodLazy<z.ZodString>;
     instanceId: z.ZodNullable<z.ZodPipe<z.ZodUnknown, z.ZodTransform<import("../index.js").InstanceId, unknown>>>;
     appId: z.ZodPipe<z.ZodUnknown, z.ZodTransform<import("@fungi.computer/puffball").AppId, unknown>>;
     release: z.ZodPipe<z.ZodUnknown, z.ZodTransform<{
@@ -74,7 +74,7 @@ export declare const installationSchema: z.ZodObject<{
         pinned: "pinned";
         floating: "floating";
     }>;
-    authorityVersion: z.ZodNumber;
+    authorityVersion: z.ZodLazy<z.ZodNumber>;
     status: z.ZodEnum<{
         enabled: "enabled";
         disabled: "disabled";
@@ -85,16 +85,16 @@ export declare const installationSchema: z.ZodObject<{
         public: "public";
     }>;
     declaredOperationsDigest: z.ZodPipe<z.ZodUnknown, z.ZodTransform<import("@fungi.computer/puffball").Sha256Digest, unknown>>;
-    approvedGrants: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
-        capability: z.ZodPipe<z.ZodUnknown, z.ZodTransform<"agent.list" | "agent.manage" | "agent.rename" | "agent.toolPolicy" | "agent.read" | "agent.send" | "computer.list" | "computer.readFile" | "computer.writeFile" | "computer.execute" | "llm.generation" | "media.generation" | "games:servers" | "git.repository" | "apps.open" | "apps.call" | "app.storage" | "app.events.emit" | "team.workbenchHost" | "marketplace.browse" | "marketplace.purchase" | "workflow.run" | "workflow.publish" | "workflow.arm" | "world" | "channels.read" | "channels.personal.manage", unknown>>;
+    approvedGrants: z.ZodLazy<z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+        capability: z.ZodPipe<z.ZodUnknown, z.ZodTransform<"agent.list" | "agent.manage" | "agent.rename" | "agent.avatar" | "agent.toolPolicy" | "agent.read" | "agent.send" | "computer.list" | "computer.readFile" | "computer.writeFile" | "computer.execute" | "llm.generation" | "media.generation" | "games:servers" | "git.repository" | "apps.open" | "apps.call" | "app.storage" | "app.events.emit" | "team.workbenchHost" | "marketplace.browse" | "marketplace.purchase" | "workflow.run" | "workflow.publish" | "workflow.arm" | "world" | "channels.read" | "channels.personal.manage", unknown>>;
         capabilityApproved: z.ZodLiteral<true>;
-        operations: z.ZodReadonly<z.ZodArray<z.ZodString>>;
-        resources: z.ZodUnion<readonly [z.ZodLiteral<"tenant-scope">, z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+        operations: z.ZodLazy<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+        resources: z.ZodUnion<readonly [z.ZodLiteral<"tenant-scope">, z.ZodReadonly<z.ZodArray<z.ZodLazy<z.ZodReadonly<z.ZodObject<{
             kind: z.ZodString;
             id: z.ZodString;
-        }, z.core.$strict>>>>]>;
-    }, z.core.$strict>>>>;
-    approval: z.ZodNullable<z.ZodReadonly<z.ZodObject<{
+        }, z.core.$strict>>>>>]>;
+    }, z.core.$strict>>>>>;
+    approval: z.ZodNullable<z.ZodLazy<z.ZodReadonly<z.ZodObject<{
         by: import("zod/mini").ZodMiniDiscriminatedUnion<[import("zod/mini").ZodMiniObject<{
             kind: import("zod/mini").ZodMiniLiteral<"member">;
             memberId: import("zod/mini").ZodMiniString<string>;
@@ -106,13 +106,13 @@ export declare const installationSchema: z.ZodObject<{
             keyId: import("zod/mini").ZodMiniString<string>;
         }, z.core.$strip>], "kind">;
         at: z.ZodNumber;
-        authorityVersion: z.ZodNumber;
-    }, z.core.$strict>>>;
+        authorityVersion: z.ZodLazy<z.ZodNumber>;
+    }, z.core.$strict>>>>;
     approvedAnonymousMethods: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
         name: z.ZodPipe<z.ZodUnknown, z.ZodTransform<string, unknown>>;
         digest: z.ZodPipe<z.ZodUnknown, z.ZodTransform<import("@fungi.computer/puffball").Sha256Digest, unknown>>;
     }, z.core.$strict>>>>;
-    anonymousApproval: z.ZodNullable<z.ZodReadonly<z.ZodObject<{
+    anonymousApproval: z.ZodNullable<z.ZodLazy<z.ZodReadonly<z.ZodObject<{
         by: import("zod/mini").ZodMiniDiscriminatedUnion<[import("zod/mini").ZodMiniObject<{
             kind: import("zod/mini").ZodMiniLiteral<"member">;
             memberId: import("zod/mini").ZodMiniString<string>;
@@ -124,19 +124,19 @@ export declare const installationSchema: z.ZodObject<{
             keyId: import("zod/mini").ZodMiniString<string>;
         }, z.core.$strip>], "kind">;
         at: z.ZodNumber;
-        authorityVersion: z.ZodNumber;
-    }, z.core.$strict>>>;
+        authorityVersion: z.ZodLazy<z.ZodNumber>;
+    }, z.core.$strict>>>>;
 }, z.core.$strict>;
 export type Installation = Readonly<z.output<typeof installationSchema>>;
 /** Host commands; floating targets have already been resolved to immutable Releases. */
-export declare const installationCommandSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+export declare const installationCommandSchema: z.ZodLazy<z.ZodDiscriminatedUnion<[z.ZodObject<{
     grants: z.ZodUnion<readonly [z.ZodLiteral<"none">, z.ZodLiteral<"declared">, z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
-        capability: z.ZodPipe<z.ZodUnknown, z.ZodTransform<"agent.list" | "agent.manage" | "agent.rename" | "agent.toolPolicy" | "agent.read" | "agent.send" | "computer.list" | "computer.readFile" | "computer.writeFile" | "computer.execute" | "llm.generation" | "media.generation" | "games:servers" | "git.repository" | "apps.open" | "apps.call" | "app.storage" | "app.events.emit" | "team.workbenchHost" | "marketplace.browse" | "marketplace.purchase" | "workflow.run" | "workflow.publish" | "workflow.arm" | "world" | "channels.read" | "channels.personal.manage", unknown>>;
-        operations: z.ZodReadonly<z.ZodArray<z.ZodString>>;
-        resources: z.ZodUnion<readonly [z.ZodLiteral<"tenant-scope">, z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+        capability: z.ZodPipe<z.ZodUnknown, z.ZodTransform<"agent.list" | "agent.manage" | "agent.rename" | "agent.avatar" | "agent.toolPolicy" | "agent.read" | "agent.send" | "computer.list" | "computer.readFile" | "computer.writeFile" | "computer.execute" | "llm.generation" | "media.generation" | "games:servers" | "git.repository" | "apps.open" | "apps.call" | "app.storage" | "app.events.emit" | "team.workbenchHost" | "marketplace.browse" | "marketplace.purchase" | "workflow.run" | "workflow.publish" | "workflow.arm" | "world" | "channels.read" | "channels.personal.manage", unknown>>;
+        operations: z.ZodLazy<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+        resources: z.ZodUnion<readonly [z.ZodLiteral<"tenant-scope">, z.ZodReadonly<z.ZodArray<z.ZodLazy<z.ZodReadonly<z.ZodObject<{
             kind: z.ZodString;
             id: z.ZodString;
-        }, z.core.$strict>>>>]>;
+        }, z.core.$strict>>>>>]>;
     }, z.core.$strict>>>>]>;
     release: z.ZodPipe<z.ZodUnknown, z.ZodTransform<{
         readonly releaseId: import("@fungi.computer/puffball").ReleaseId;
@@ -191,12 +191,12 @@ export declare const installationCommandSchema: z.ZodDiscriminatedUnion<[z.ZodOb
 }, z.core.$strict>, z.ZodObject<{
     kind: z.ZodLiteral<"set-grants">;
     grants: z.ZodUnion<readonly [z.ZodLiteral<"none">, z.ZodLiteral<"declared">, z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
-        capability: z.ZodPipe<z.ZodUnknown, z.ZodTransform<"agent.list" | "agent.manage" | "agent.rename" | "agent.toolPolicy" | "agent.read" | "agent.send" | "computer.list" | "computer.readFile" | "computer.writeFile" | "computer.execute" | "llm.generation" | "media.generation" | "games:servers" | "git.repository" | "apps.open" | "apps.call" | "app.storage" | "app.events.emit" | "team.workbenchHost" | "marketplace.browse" | "marketplace.purchase" | "workflow.run" | "workflow.publish" | "workflow.arm" | "world" | "channels.read" | "channels.personal.manage", unknown>>;
-        operations: z.ZodReadonly<z.ZodArray<z.ZodString>>;
-        resources: z.ZodUnion<readonly [z.ZodLiteral<"tenant-scope">, z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+        capability: z.ZodPipe<z.ZodUnknown, z.ZodTransform<"agent.list" | "agent.manage" | "agent.rename" | "agent.avatar" | "agent.toolPolicy" | "agent.read" | "agent.send" | "computer.list" | "computer.readFile" | "computer.writeFile" | "computer.execute" | "llm.generation" | "media.generation" | "games:servers" | "git.repository" | "apps.open" | "apps.call" | "app.storage" | "app.events.emit" | "team.workbenchHost" | "marketplace.browse" | "marketplace.purchase" | "workflow.run" | "workflow.publish" | "workflow.arm" | "world" | "channels.read" | "channels.personal.manage", unknown>>;
+        operations: z.ZodLazy<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+        resources: z.ZodUnion<readonly [z.ZodLiteral<"tenant-scope">, z.ZodReadonly<z.ZodArray<z.ZodLazy<z.ZodReadonly<z.ZodObject<{
             kind: z.ZodString;
             id: z.ZodString;
-        }, z.core.$strict>>>>]>;
+        }, z.core.$strict>>>>>]>;
     }, z.core.$strict>>>>]>;
 }, z.core.$strict>, z.ZodObject<{
     kind: z.ZodLiteral<"approve-anonymous">;
@@ -204,7 +204,7 @@ export declare const installationCommandSchema: z.ZodDiscriminatedUnion<[z.ZodOb
         name: z.ZodPipe<z.ZodUnknown, z.ZodTransform<string, unknown>>;
         digest: z.ZodPipe<z.ZodUnknown, z.ZodTransform<import("@fungi.computer/puffball").Sha256Digest, unknown>>;
     }, z.core.$strict>>>>;
-}, z.core.$strict>], "kind">;
+}, z.core.$strict>], "kind">>;
 export type InstallationCommand = z.output<typeof installationCommandSchema>;
 /** Values captured by the host; identities and time are never generated by the reducer. */
 export type InstallationContext = Readonly<{
@@ -221,7 +221,7 @@ export type InstallationContext = Readonly<{
     }>;
 }>;
 /** Closed refusals: failed commands produce no installation update. */
-export declare const installationRefusalSchema: z.ZodObject<{
+export declare const installationRefusalSchema: z.ZodLazy<z.ZodObject<{
     kind: z.ZodLiteral<"refused">;
     code: z.ZodEnum<{
         unavailable: "unavailable";
@@ -231,7 +231,7 @@ export declare const installationRefusalSchema: z.ZodObject<{
         not_owner: "not_owner";
         invalid_command: "invalid_command";
     }>;
-}, z.core.$strict>;
+}, z.core.$strict>>;
 export type InstallationRefusal = z.output<typeof installationRefusalSchema>;
 export type InstallationUpdate = Readonly<{
     next: Installation;

package/dist/apps/installation.js

@@ -20,20 +20,18 @@ export function ownerCodec(schema) {
     });
 }
 /** Installation names cannot contain the tenant separator. */
-export const installationIdSchema = z
-    .string()
-    .regex(/^[a-z](?:[a-z0-9]|-(?!-)){0,62}$/u);
+export const installationIdSchema = z.lazy(() => z.string().regex(/^[a-z](?:[a-z0-9]|-(?!-)){0,62}$/u));
 /** A resource identity minted and resolved by the host, never by this module. */
-const resourceRefSchema = z
+const resourceRefSchema = z.lazy(() => z
     .strictObject({
     kind: z.string().min(1),
     id: z.string().min(1),
 })
-    .readonly();
-const operationsSchema = z
+    .readonly());
+const operationsSchema = z.lazy(() => z
     .array(z.string().min(1))
     .refine((values) => new Set(values).size === values.length, "Operations must be unique")
-    .readonly();
+    .readonly());
 /**
  * Consent approves capabilities, with explicit operation and resource ceilings.
  * A Release adding a method that requires an already-approved capability needs
@@ -58,10 +56,10 @@ export const approvedGrantSchema = z
 })
     .readonly();
 /** One grant per capability keeps operation/resource pairs unambiguous. */
-const approvedGrantsSchema = z
+const approvedGrantsSchema = z.lazy(() => z
     .array(approvedGrantSchema)
     .refine((grants) => new Set(grants.map((grant) => grant.capability)).size === grants.length, "Capabilities must be unique")
-    .readonly();
+    .readonly());
 /** Shorthand is accepted only on a command and expanded at approval time. */
 const grantRequestSchema = z.union([
     z.literal("none"),
@@ -74,15 +72,15 @@ const grantRequestSchema = z.union([
         .refine((grants) => new Set(grants.map((grant) => grant.capability)).size === grants.length, "Capabilities must be unique")
         .readonly(),
 ]);
-const versionSchema = z.number().int().positive();
+const versionSchema = z.lazy(() => z.number().int().positive());
 /** An owner's approval of a fixed operation snapshot. */
-const approvalSchema = z
+const approvalSchema = z.lazy(() => z
     .strictObject({
     by: hostActorSchema,
     at: z.number().int().nonnegative(),
     authorityVersion: versionSchema,
 })
-    .readonly();
+    .readonly());
 const anonymousMethodsSchema = z
     .array(z
     .strictObject({
@@ -96,7 +94,7 @@ const anonymousMethodsSchema = z
 }), "Anonymous method identities must have unique, sorted names")
     .readonly();
 /** Immutable operation facts derived from descriptor methods and the binding registry. */
-export const declaredOperationsSchema = z.strictObject({
+export const declaredOperationsSchema = z.lazy(() => z.strictObject({
     artifactDigest: ownerCodec(sha256DigestSchema),
     digest: ownerCodec(sha256DigestSchema),
     anonymousMethods: anonymousMethodsSchema,
@@ -108,7 +106,7 @@ export const declaredOperationsSchema = z.strictObject({
     })
         .readonly())
         .readonly(),
-});
+}));
 /** Resolved immutable Release plus host-owned installation and approval state. */
 export const installationSchema = z
     .strictObject({
@@ -141,7 +139,7 @@ const releaseFields = {
     releasePin: installationSchema.shape.releasePin,
 };
 /** Host commands; floating targets have already been resolved to immutable Releases. */
-export const installationCommandSchema = z.discriminatedUnion("kind", [
+export const installationCommandSchema = z.lazy(() => z.discriminatedUnion("kind", [
     z.strictObject({
         kind: z.literal("install"),
         ...releaseFields,
@@ -156,14 +154,17 @@ export const installationCommandSchema = z.discriminatedUnion("kind", [
         kind: z.literal("set-visibility"),
         visibility: installationSchema.shape.visibility,
     }),
-    z.strictObject({ kind: z.literal("set-grants"), grants: grantRequestSchema }),
+    z.strictObject({
+        kind: z.literal("set-grants"),
+        grants: grantRequestSchema,
+    }),
     z.strictObject({
         kind: z.literal("approve-anonymous"),
         methods: anonymousMethodsSchema,
     }),
-]);
+]));
 /** Closed refusals: failed commands produce no installation update. */
-export const installationRefusalSchema = z.strictObject({
+export const installationRefusalSchema = z.lazy(() => z.strictObject({
     kind: z.literal("refused"),
     code: z.enum([
         "unavailable",
@@ -173,7 +174,7 @@ export const installationRefusalSchema = z.strictObject({
         "release_app_mismatch",
         "invalid_command",
     ]),
-});
+}));
 /** Pure transition; hosts retain transactions, receipts, epochs and delivery. */
 export function applyInstallationCommand(current, rawCommand, context) {
     const refuse = (code) => Result.fail({ kind: "refused", code });

package/dist/build/artifact-writer.d.ts

@@ -0,0 +1,40 @@
+import { type AssetBuildPolicy } from "@fungi.computer/puffball/assets";
+import { type ArtifactRef, type Sha256Digest } from "@fungi.computer/puffball";
+import type { BuildOutput, StoredArtifact } from "./effect.js";
+import type { CandidateOutputManifest } from "./submission-contract.js";
+/** Write-once object storage for one artifact root. */
+export type ImmutableArtifactObjects = Readonly<{
+    /** Create the object, or answer `exists` when the reference is taken. */
+    create(artifactRef: ArtifactRef, bytes: Uint8Array): Promise<"created" | "exists">;
+    /** Read the object's bytes, or `null` when absent. */
+    read(artifactRef: ArtifactRef): Promise<Uint8Array | null>;
+}>;
+/** One object ready to store under its reference. */
+export type StagedArtifactObject = Readonly<{
+    artifactRef: ArtifactRef;
+    bytes: Uint8Array;
+    digest: Sha256Digest;
+}>;
+/** A build's output manifest and each distinct object it names. */
+export type StagedBuildOutput = Readonly<{
+    manifest: CandidateOutputManifest;
+    objects: readonly StagedArtifactObject[];
+}>;
+/**
+ * Stage a build's bytes: the output manifest that names each object by its
+ * digest and size, and each distinct object once.
+ */
+export declare function stageBuildOutput(output: BuildOutput): StagedBuildOutput;
+/**
+ * Write the asset manifest and App root an output manifest names. The
+ * objects it names are already stored, and checked, by the caller.
+ */
+export declare function writeArtifactRoot(manifest: CandidateOutputManifest, objects: ImmutableArtifactObjects, options: Readonly<{
+    rootArtifactRef: ArtifactRef;
+    assetPolicy: AssetBuildPolicy | undefined;
+}>): Promise<StoredArtifact>;
+/** Persist one build's UI, backend and root; an existing object must hold the same bytes. */
+export declare function writeImmutableArtifact(output: BuildOutput, objects: ImmutableArtifactObjects, options: Readonly<{
+    rootArtifactRef: ArtifactRef;
+    assetPolicy: AssetBuildPolicy | undefined;
+}>): Promise<StoredArtifact>;

package/dist/build/artifact-writer.js

@@ -0,0 +1,181 @@
+/**
+ * Oyster's one immutable artifact representation: digest-addressed bytes
+ * keyed by artifact reference, with media types carried by the App build
+ * and asset manifests (never by the store). The local packer writes it to a
+ * directory, and a host's build owner writes it to that host's artifact store,
+ * so a Release built on the host and one packed and uploaded share objects.
+ *
+ * It has two halves. Staging turns a build's bytes into content-addressed
+ * objects and the output manifest that names them by digest and size. The
+ * root half turns an output manifest into the small objects only the store's
+ * owner writes: the asset manifest and the App root. The local packer runs
+ * both; a host whose builder uploaded the objects itself runs only the root
+ * half, over the same manifest, so both write identical root bytes.
+ *
+ * Every object is derived and checked before the first is stored: an asset
+ * build that its policy refuses, or a root over its bound, stores nothing.
+ */
+import { createHash } from "node:crypto";
+import mime from "mime";
+import * as Schema from "effect/Schema";
+import { assetBuildJsonSchema, assetPathSchema, decodeAssetBuild, } from "@fungi.computer/puffball/assets";
+import { appBuildJsonSchema, createAppBuild, } from "@fungi.computer/puffball/app";
+import { parseArtifactRef, parseSha256Digest, } from "@fungi.computer/puffball";
+function sha256(bytes) {
+    return parseSha256Digest(`sha256:${createHash("sha256").update(bytes).digest("hex")}`);
+}
+/** The content address of an object: `artifact:sha256-<hex>`. */
+function contentArtifactRef(digest) {
+    return parseArtifactRef(`artifact:sha256-${digest.slice("sha256:".length)}`);
+}
+/**
+ * The root bound for an App whose recipe declares no asset policy: this
+ * writer's private fallback, not recipe policy. An asset recipe's own
+ * `maxManifestBytes` bounds its root as it bounds its asset manifest.
+ */
+const fallbackRootBytes = 1024 * 1024;
+/**
+ * Stage a build's bytes: the output manifest that names each object by its
+ * digest and size, and each distinct object once.
+ */
+export function stageBuildOutput(output) {
+    const objects = [];
+    const stage = (bytes) => {
+        const digest = sha256(bytes);
+        if (!objects.some((object) => object.digest === digest))
+            objects.push({
+                artifactRef: contentArtifactRef(digest),
+                bytes: bytes.slice(),
+                digest,
+            });
+        return { digest, byteLength: bytes.byteLength };
+    };
+    const declared = output.declaration === undefined ? {} : { declaration: output.declaration };
+    const ui = (prepared) => prepared.content.kind === "html"
+        ? {
+            mediaType: "text/html; charset=utf-8",
+            content: { kind: "html", ...stage(prepared.content.bytes) },
+        }
+        : {
+            mediaType: "application/vnd.fungi.app-assets+json",
+            content: {
+                kind: "assets",
+                base: prepared.content.base,
+                assets: prepared.content.assets.map((asset) => ({
+                    path: asset.path,
+                    ...stage(asset.bytes),
+                })),
+            },
+        };
+    const manifest = output.kind === "ui"
+        ? { kind: "ui", ui: ui(output.ui), ...declared }
+        : output.kind === "backend"
+            ? { kind: "backend", backend: stage(output.backend), ...declared }
+            : {
+                kind: "app",
+                ui: ui(output.ui),
+                backend: stage(output.backend),
+                ...declared,
+            };
+    return { manifest, objects };
+}
+/**
+ * Derive the asset manifest (for an asset UI) and the App root an output
+ * manifest names, each checked against the policy, without storing either.
+ */
+function artifactRootObjects(manifest, options) {
+    const objects = [];
+    const referenced = (object) => ({
+        artifactRef: contentArtifactRef(object.digest),
+        digest: object.digest,
+        version: object.digest,
+        byteLength: object.byteLength,
+    });
+    const stage = (bytes, ref) => {
+        const digest = sha256(bytes);
+        const artifactRef = ref ?? contentArtifactRef(digest);
+        objects.push({ artifactRef, bytes, digest });
+        return {
+            artifactRef,
+            digest,
+            version: digest,
+            byteLength: bytes.byteLength,
+        };
+    };
+    const ui = manifest.kind === "backend" ? null : manifest.ui;
+    const storedUi = (() => {
+        if (ui === null)
+            return null;
+        if (ui.content.kind === "html")
+            return { ...referenced(ui.content), mediaType: ui.mediaType };
+        if (!options.assetPolicy)
+            throw new Error("Asset writer requires explicit policy");
+        const byPath = new Map();
+        for (const asset of ui.content.assets) {
+            const path = Schema.decodeUnknownSync(assetPathSchema)(asset.path);
+            if (byPath.has(path))
+                throw new Error("Duplicate build path");
+            byPath.set(path, asset);
+        }
+        const assets = [];
+        for (const [path, asset] of [...byPath].sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0)) {
+            const mediaType = mime.getType(path);
+            const contentType = mediaType?.startsWith("text/")
+                ? `${mediaType}; charset=utf-8`
+                : mediaType;
+            if (!contentType)
+                throw new Error("Build asset has no maintained content type");
+            assets.push({ path, ...referenced(asset), contentType });
+        }
+        const assetManifest = new TextEncoder().encode(Schema.encodeUnknownSync(assetBuildJsonSchema)({
+            format: "fungi-assets-v1",
+            base: ui.content.base,
+            assets,
+        }));
+        decodeAssetBuild(assetManifest, options.assetPolicy);
+        return { ...stage(assetManifest), mediaType: ui.mediaType };
+    })();
+    const storedBackend = manifest.kind === "ui"
+        ? null
+        : {
+            ...referenced(manifest.backend),
+            mediaType: "application/vnd.fungi.app-backend+json",
+        };
+    const rootBytes = new TextEncoder().encode(Schema.encodeUnknownSync(appBuildJsonSchema)(createAppBuild(storedUi, storedBackend, manifest.declaration)));
+    if (rootBytes.byteLength >
+        (options.assetPolicy?.maxManifestBytes ?? fallbackRootBytes))
+        throw new Error("App root exceeds its manifest bound");
+    const root = stage(rootBytes, options.rootArtifactRef);
+    return {
+        objects,
+        root: Object.freeze({
+            artifactRef: root.artifactRef,
+            artifactDigest: root.digest,
+        }),
+    };
+}
+/** Store each object once; an existing object must hold the same bytes. */
+async function storeObjects(staged, objects) {
+    for (const { artifactRef, bytes, digest } of staged)
+        if ((await objects.create(artifactRef, bytes)) === "exists") {
+            const existing = await objects.read(artifactRef);
+            if (existing === null || sha256(existing) !== digest)
+                throw new Error("Immutable artifact collision");
+        }
+}
+/**
+ * Write the asset manifest and App root an output manifest names. The
+ * objects it names are already stored, and checked, by the caller.
+ */
+export async function writeArtifactRoot(manifest, objects, options) {
+    const derived = artifactRootObjects(manifest, options);
+    await storeObjects(derived.objects, objects);
+    return derived.root;
+}
+/** Persist one build's UI, backend and root; an existing object must hold the same bytes. */
+export async function writeImmutableArtifact(output, objects, options) {
+    const staged = stageBuildOutput(output);
+    const derived = artifactRootObjects(staged.manifest, options);
+    await storeObjects([...staged.objects, ...derived.objects], objects);
+    return derived.root;
+}

package/dist/build/build-jobs.js

@@ -52,6 +52,7 @@ var __disposeResources = (this && this.__disposeResources) || (function (Suppres
 });
 import * as Schema from "effect/Schema";
 import { base64url } from "jose";
+import { workspaceBuildPolicy } from "./build-policy.js";
 /** The secret-free Team job; no provider token enters publication. */
 const jobSchema = Schema.Struct({
     jobId: Schema.NonEmptyString,
@@ -177,6 +178,8 @@ export function createTeamBuildPublisher(options) {
 export function teamAppBuildCommand(configuration, uploadGrant) {
     const encoded = base64url.encode(JSON.stringify({
         uploadGrant,
+        // A builder that predates this policy refuses the whole request.
+        buildPolicy: workspaceBuildPolicy,
         appId: configuration.appId,
         sourceRevision: configuration.sourceRevision,
         recipe: configuration.source.recipe,
@@ -191,7 +194,10 @@ export function teamAppBuildCommand(configuration, uploadGrant) {
         `trap 'rm -rf "$work"' EXIT`,
         'mkdir "$work/tmp"',
         'export TMPDIR="$work/tmp"',
+        "clone_started=$(date +%s%3N)",
         'git clone -q --no-checkout -- "$TEAM_BUILD_REMOTE" "$work/source" 2>/dev/null',
-        `node /opt/fungi/team-candidate-builder.mjs '${encoded}' "$work/source" "$work/candidate.json"`,
+        // The builder reports each phase's duration with its outcome.
+        "export TEAM_BUILD_CLONE_MS=$(( $(date +%s%3N) - clone_started ))",
+        `node /opt/fungi/team-candidate-builder.mjs '${encoded}' "$work/source" "$work/candidate"`,
     ].join("\n");
 }

package/dist/build/build-policy.d.ts

@@ -0,0 +1,10 @@
+/**
+ * The pinned workspace build policy: how a captured workspace's manifests
+ * build (`package.json#fungi.build`). v2 lets a dependency name its own
+ * package build script, which only an admitted Computer build runs.
+ *
+ * It is part of every workspace HTML recipe's toolchain, so its digest moves
+ * with it, and the Computer build request carries it at the top level, where
+ * a builder compiled before it existed refuses the request outright.
+ */
+export declare const workspaceBuildPolicy = "package-json-fungi-build-v2";

package/dist/build/build-policy.js

@@ -0,0 +1,10 @@
+/**
+ * The pinned workspace build policy: how a captured workspace's manifests
+ * build (`package.json#fungi.build`). v2 lets a dependency name its own
+ * package build script, which only an admitted Computer build runs.
+ *
+ * It is part of every workspace HTML recipe's toolchain, so its digest moves
+ * with it, and the Computer build request carries it at the top level, where
+ * a builder compiled before it existed refuses the request outright.
+ */
+export const workspaceBuildPolicy = "package-json-fungi-build-v2";

package/dist/build/build-step.d.ts

@@ -3,7 +3,10 @@ import * as Schema from "effect/Schema";
  * One captured dependency build step. Paths are relative to the captured
  * snapshot root. A TypeScript step compiles one config; a Tailwind step
  * compiles one stylesheet input into its output (the same path for an App's
- * own stylesheet, which compiles in place).
+ * own stylesheet, which compiles in place). A script step runs the one
+ * `package.json` script a workspace dependency names as its build
+ * (`fungi.build.script`), with pnpm, in that package's directory; only an
+ * admitted Computer build executes it.
  */
 export declare const workspaceBuildStepSchema: Schema.Union<readonly [Schema.Struct<{
     readonly kind: Schema.Literal<"typescript">;
@@ -12,6 +15,10 @@ export declare const workspaceBuildStepSchema: Schema.Union<readonly [Schema.Str
     readonly kind: Schema.Literal<"tailwind">;
     readonly input: Schema.String;
     readonly output: Schema.String;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"script">;
+    readonly directory: Schema.String;
+    readonly script: Schema.String;
 }>]>;
 /** One captured dependency build step. */
 export type WorkspaceBuildStep = Schema.Schema.Type<typeof workspaceBuildStepSchema>;
@@ -23,4 +30,8 @@ export declare const workspaceBuildStepsJsonSchema: Schema.fromJsonString<Schema
     readonly kind: Schema.Literal<"tailwind">;
     readonly input: Schema.String;
     readonly output: Schema.String;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"script">;
+    readonly directory: Schema.String;
+    readonly script: Schema.String;
 }>]>>>;

package/dist/build/build-step.js

@@ -3,7 +3,10 @@ import * as Schema from "effect/Schema";
  * One captured dependency build step. Paths are relative to the captured
  * snapshot root. A TypeScript step compiles one config; a Tailwind step
  * compiles one stylesheet input into its output (the same path for an App's
- * own stylesheet, which compiles in place).
+ * own stylesheet, which compiles in place). A script step runs the one
+ * `package.json` script a workspace dependency names as its build
+ * (`fungi.build.script`), with pnpm, in that package's directory; only an
+ * admitted Computer build executes it.
  */
 export const workspaceBuildStepSchema = Schema.Union([
     Schema.Struct({
@@ -15,6 +18,11 @@ export const workspaceBuildStepSchema = Schema.Union([
         input: Schema.String,
         output: Schema.String,
     }),
+    Schema.Struct({
+        kind: Schema.Literal("script"),
+        directory: Schema.String,
+        script: Schema.String,
+    }),
 ]);
 /** The steps one dependency-build process runs, encoded as one argument. */
 export const workspaceBuildStepsJsonSchema = Schema.fromJsonString(Schema.Array(workspaceBuildStepSchema));