@fungi.computer/oyster 0.0.0-stage → 0.0.1

package/dist/build/submission-contract.d.ts

@@ -0,0 +1,384 @@
+import * as Schema from "effect/Schema";
+/** The largest Team App candidate submission request body, in bytes. */
+export declare const TEAM_APP_SUBMISSION_MAX_REQUEST_BYTES: number;
+/** Exact submitted output and provenance before the Team assigns a stable Release ID. */
+export declare const teamAppCandidateSubmissionSchema: Schema.Struct<{
+    appId: Schema.refine<import("@fungi.computer/puffball").AppId, Schema.String>;
+    output: Schema.Union<readonly [Schema.Struct<{
+        readonly declaration: Schema.optionalKey<Schema.Codec<Readonly<{
+            api?: import("@fungi.computer/puffball").AppApi;
+            displayName?: string | undefined;
+            capabilities: readonly import("@fungi.computer/puffball").AppCapabilityId[];
+            calls?: readonly Readonly<{
+                appId: string;
+                methods: readonly string[];
+            }>[] | undefined;
+            guidance?: string | undefined;
+            handlers: readonly import("@fungi.computer/puffball").AppHandler[];
+            receives?: readonly "git.push"[] | undefined;
+            icon?: string;
+            roles: readonly import("@fungi.computer/puffball").AppRole[];
+            storage?: readonly import("@fungi.computer/puffball").AppStorageKey[] | undefined;
+            commands?: readonly import("@fungi.computer/puffball").AppDeclaredCommand[] | undefined;
+            gills?: readonly import("@fungi.computer/gills").AppDeclaredGill[] | undefined;
+            backend?: Readonly<{
+                bindings: readonly import("@fungi.computer/puffball").AppBackendBinding[];
+                sync?: Readonly<{
+                    method: string;
+                }>;
+            }> | undefined;
+        }>, Readonly<{
+            api?: import("@fungi.computer/puffball").AppApi;
+            displayName?: string | undefined;
+            capabilities: readonly import("@fungi.computer/puffball").AppCapabilityId[];
+            calls?: readonly Readonly<{
+                appId: string;
+                methods: readonly string[];
+            }>[] | undefined;
+            guidance?: string | undefined;
+            handlers: readonly import("@fungi.computer/puffball").AppHandler[];
+            receives?: readonly "git.push"[] | undefined;
+            icon?: string;
+            roles: readonly import("@fungi.computer/puffball").AppRole[];
+            storage?: readonly import("@fungi.computer/puffball").AppStorageKey[] | undefined;
+            commands?: readonly import("@fungi.computer/puffball").AppDeclaredCommand[] | undefined;
+            gills?: readonly import("@fungi.computer/gills").AppDeclaredGill[] | undefined;
+            backend?: Readonly<{
+                bindings: readonly import("@fungi.computer/puffball").AppBackendBinding[];
+                sync?: Readonly<{
+                    method: string;
+                }>;
+            }> | undefined;
+        }>, never, never>>;
+        readonly kind: Schema.Literal<"ui">;
+        readonly ui: Schema.Union<readonly [Schema.Struct<{
+            readonly mediaType: Schema.Literal<"text/html; charset=utf-8">;
+            readonly content: Schema.Struct<{
+                readonly kind: Schema.Literal<"html">;
+                readonly bytes: Schema.Uint8ArrayFromBase64;
+            }>;
+        }>, Schema.Struct<{
+            readonly mediaType: Schema.Literal<"application/vnd.fungi.app-assets+json">;
+            readonly content: Schema.Struct<{
+                readonly kind: Schema.Literal<"assets">;
+                readonly base: Schema.String;
+                readonly assets: Schema.$Array<Schema.Struct<{
+                    readonly path: Schema.String;
+                    readonly bytes: Schema.Uint8ArrayFromBase64;
+                }>>;
+            }>;
+        }>]>;
+    }>, Schema.Struct<{
+        readonly declaration: Schema.optionalKey<Schema.Codec<Readonly<{
+            api?: import("@fungi.computer/puffball").AppApi;
+            displayName?: string | undefined;
+            capabilities: readonly import("@fungi.computer/puffball").AppCapabilityId[];
+            calls?: readonly Readonly<{
+                appId: string;
+                methods: readonly string[];
+            }>[] | undefined;
+            guidance?: string | undefined;
+            handlers: readonly import("@fungi.computer/puffball").AppHandler[];
+            receives?: readonly "git.push"[] | undefined;
+            icon?: string;
+            roles: readonly import("@fungi.computer/puffball").AppRole[];
+            storage?: readonly import("@fungi.computer/puffball").AppStorageKey[] | undefined;
+            commands?: readonly import("@fungi.computer/puffball").AppDeclaredCommand[] | undefined;
+            gills?: readonly import("@fungi.computer/gills").AppDeclaredGill[] | undefined;
+            backend?: Readonly<{
+                bindings: readonly import("@fungi.computer/puffball").AppBackendBinding[];
+                sync?: Readonly<{
+                    method: string;
+                }>;
+            }> | undefined;
+        }>, Readonly<{
+            api?: import("@fungi.computer/puffball").AppApi;
+            displayName?: string | undefined;
+            capabilities: readonly import("@fungi.computer/puffball").AppCapabilityId[];
+            calls?: readonly Readonly<{
+                appId: string;
+                methods: readonly string[];
+            }>[] | undefined;
+            guidance?: string | undefined;
+            handlers: readonly import("@fungi.computer/puffball").AppHandler[];
+            receives?: readonly "git.push"[] | undefined;
+            icon?: string;
+            roles: readonly import("@fungi.computer/puffball").AppRole[];
+            storage?: readonly import("@fungi.computer/puffball").AppStorageKey[] | undefined;
+            commands?: readonly import("@fungi.computer/puffball").AppDeclaredCommand[] | undefined;
+            gills?: readonly import("@fungi.computer/gills").AppDeclaredGill[] | undefined;
+            backend?: Readonly<{
+                bindings: readonly import("@fungi.computer/puffball").AppBackendBinding[];
+                sync?: Readonly<{
+                    method: string;
+                }>;
+            }> | undefined;
+        }>, never, never>>;
+        readonly kind: Schema.Literal<"backend">;
+        readonly backend: Schema.Uint8ArrayFromBase64;
+    }>, Schema.Struct<{
+        readonly declaration: Schema.optionalKey<Schema.Codec<Readonly<{
+            api?: import("@fungi.computer/puffball").AppApi;
+            displayName?: string | undefined;
+            capabilities: readonly import("@fungi.computer/puffball").AppCapabilityId[];
+            calls?: readonly Readonly<{
+                appId: string;
+                methods: readonly string[];
+            }>[] | undefined;
+            guidance?: string | undefined;
+            handlers: readonly import("@fungi.computer/puffball").AppHandler[];
+            receives?: readonly "git.push"[] | undefined;
+            icon?: string;
+            roles: readonly import("@fungi.computer/puffball").AppRole[];
+            storage?: readonly import("@fungi.computer/puffball").AppStorageKey[] | undefined;
+            commands?: readonly import("@fungi.computer/puffball").AppDeclaredCommand[] | undefined;
+            gills?: readonly import("@fungi.computer/gills").AppDeclaredGill[] | undefined;
+            backend?: Readonly<{
+                bindings: readonly import("@fungi.computer/puffball").AppBackendBinding[];
+                sync?: Readonly<{
+                    method: string;
+                }>;
+            }> | undefined;
+        }>, Readonly<{
+            api?: import("@fungi.computer/puffball").AppApi;
+            displayName?: string | undefined;
+            capabilities: readonly import("@fungi.computer/puffball").AppCapabilityId[];
+            calls?: readonly Readonly<{
+                appId: string;
+                methods: readonly string[];
+            }>[] | undefined;
+            guidance?: string | undefined;
+            handlers: readonly import("@fungi.computer/puffball").AppHandler[];
+            receives?: readonly "git.push"[] | undefined;
+            icon?: string;
+            roles: readonly import("@fungi.computer/puffball").AppRole[];
+            storage?: readonly import("@fungi.computer/puffball").AppStorageKey[] | undefined;
+            commands?: readonly import("@fungi.computer/puffball").AppDeclaredCommand[] | undefined;
+            gills?: readonly import("@fungi.computer/gills").AppDeclaredGill[] | undefined;
+            backend?: Readonly<{
+                bindings: readonly import("@fungi.computer/puffball").AppBackendBinding[];
+                sync?: Readonly<{
+                    method: string;
+                }>;
+            }> | undefined;
+        }>, never, never>>;
+        readonly kind: Schema.Literal<"app">;
+        readonly ui: Schema.Union<readonly [Schema.Struct<{
+            readonly mediaType: Schema.Literal<"text/html; charset=utf-8">;
+            readonly content: Schema.Struct<{
+                readonly kind: Schema.Literal<"html">;
+                readonly bytes: Schema.Uint8ArrayFromBase64;
+            }>;
+        }>, Schema.Struct<{
+            readonly mediaType: Schema.Literal<"application/vnd.fungi.app-assets+json">;
+            readonly content: Schema.Struct<{
+                readonly kind: Schema.Literal<"assets">;
+                readonly base: Schema.String;
+                readonly assets: Schema.$Array<Schema.Struct<{
+                    readonly path: Schema.String;
+                    readonly bytes: Schema.Uint8ArrayFromBase64;
+                }>>;
+            }>;
+        }>]>;
+        readonly backend: Schema.Uint8ArrayFromBase64;
+    }>]>;
+    provenance: Schema.Struct<{
+        readonly sourceRevision: Schema.refine<import("@fungi.computer/puffball").SourceRevision, Schema.String>;
+        readonly sourceTreeDigest: Schema.refine<import("@fungi.computer/puffball").Sha256Digest, Schema.String>;
+        readonly buildRecipeDigest: Schema.refine<import("@fungi.computer/puffball").Sha256Digest, Schema.String>;
+    }>;
+}>;
+/** Publisher persistence input after TeamDO reserves retry-stable identities. */
+export declare const preparedCandidateSchema: Schema.Struct<{
+    readonly releaseId: Schema.refine<import("@fungi.computer/puffball").ReleaseId, Schema.String>;
+    readonly appId: Schema.refine<import("@fungi.computer/puffball").AppId, Schema.String>;
+    readonly output: Schema.Union<readonly [Schema.Struct<{
+        readonly declaration: Schema.optionalKey<Schema.Codec<Readonly<{
+            api?: import("@fungi.computer/puffball").AppApi;
+            displayName?: string | undefined;
+            capabilities: readonly import("@fungi.computer/puffball").AppCapabilityId[];
+            calls?: readonly Readonly<{
+                appId: string;
+                methods: readonly string[];
+            }>[] | undefined;
+            guidance?: string | undefined;
+            handlers: readonly import("@fungi.computer/puffball").AppHandler[];
+            receives?: readonly "git.push"[] | undefined;
+            icon?: string;
+            roles: readonly import("@fungi.computer/puffball").AppRole[];
+            storage?: readonly import("@fungi.computer/puffball").AppStorageKey[] | undefined;
+            commands?: readonly import("@fungi.computer/puffball").AppDeclaredCommand[] | undefined;
+            gills?: readonly import("@fungi.computer/gills").AppDeclaredGill[] | undefined;
+            backend?: Readonly<{
+                bindings: readonly import("@fungi.computer/puffball").AppBackendBinding[];
+                sync?: Readonly<{
+                    method: string;
+                }>;
+            }> | undefined;
+        }>, Readonly<{
+            api?: import("@fungi.computer/puffball").AppApi;
+            displayName?: string | undefined;
+            capabilities: readonly import("@fungi.computer/puffball").AppCapabilityId[];
+            calls?: readonly Readonly<{
+                appId: string;
+                methods: readonly string[];
+            }>[] | undefined;
+            guidance?: string | undefined;
+            handlers: readonly import("@fungi.computer/puffball").AppHandler[];
+            receives?: readonly "git.push"[] | undefined;
+            icon?: string;
+            roles: readonly import("@fungi.computer/puffball").AppRole[];
+            storage?: readonly import("@fungi.computer/puffball").AppStorageKey[] | undefined;
+            commands?: readonly import("@fungi.computer/puffball").AppDeclaredCommand[] | undefined;
+            gills?: readonly import("@fungi.computer/gills").AppDeclaredGill[] | undefined;
+            backend?: Readonly<{
+                bindings: readonly import("@fungi.computer/puffball").AppBackendBinding[];
+                sync?: Readonly<{
+                    method: string;
+                }>;
+            }> | undefined;
+        }>, never, never>>;
+        readonly kind: Schema.Literal<"ui">;
+        readonly ui: Schema.Union<readonly [Schema.Struct<{
+            readonly mediaType: Schema.Literal<"text/html; charset=utf-8">;
+            readonly content: Schema.Struct<{
+                readonly kind: Schema.Literal<"html">;
+                readonly bytes: Schema.Uint8ArrayFromBase64;
+            }>;
+        }>, Schema.Struct<{
+            readonly mediaType: Schema.Literal<"application/vnd.fungi.app-assets+json">;
+            readonly content: Schema.Struct<{
+                readonly kind: Schema.Literal<"assets">;
+                readonly base: Schema.String;
+                readonly assets: Schema.$Array<Schema.Struct<{
+                    readonly path: Schema.String;
+                    readonly bytes: Schema.Uint8ArrayFromBase64;
+                }>>;
+            }>;
+        }>]>;
+    }>, Schema.Struct<{
+        readonly declaration: Schema.optionalKey<Schema.Codec<Readonly<{
+            api?: import("@fungi.computer/puffball").AppApi;
+            displayName?: string | undefined;
+            capabilities: readonly import("@fungi.computer/puffball").AppCapabilityId[];
+            calls?: readonly Readonly<{
+                appId: string;
+                methods: readonly string[];
+            }>[] | undefined;
+            guidance?: string | undefined;
+            handlers: readonly import("@fungi.computer/puffball").AppHandler[];
+            receives?: readonly "git.push"[] | undefined;
+            icon?: string;
+            roles: readonly import("@fungi.computer/puffball").AppRole[];
+            storage?: readonly import("@fungi.computer/puffball").AppStorageKey[] | undefined;
+            commands?: readonly import("@fungi.computer/puffball").AppDeclaredCommand[] | undefined;
+            gills?: readonly import("@fungi.computer/gills").AppDeclaredGill[] | undefined;
+            backend?: Readonly<{
+                bindings: readonly import("@fungi.computer/puffball").AppBackendBinding[];
+                sync?: Readonly<{
+                    method: string;
+                }>;
+            }> | undefined;
+        }>, Readonly<{
+            api?: import("@fungi.computer/puffball").AppApi;
+            displayName?: string | undefined;
+            capabilities: readonly import("@fungi.computer/puffball").AppCapabilityId[];
+            calls?: readonly Readonly<{
+                appId: string;
+                methods: readonly string[];
+            }>[] | undefined;
+            guidance?: string | undefined;
+            handlers: readonly import("@fungi.computer/puffball").AppHandler[];
+            receives?: readonly "git.push"[] | undefined;
+            icon?: string;
+            roles: readonly import("@fungi.computer/puffball").AppRole[];
+            storage?: readonly import("@fungi.computer/puffball").AppStorageKey[] | undefined;
+            commands?: readonly import("@fungi.computer/puffball").AppDeclaredCommand[] | undefined;
+            gills?: readonly import("@fungi.computer/gills").AppDeclaredGill[] | undefined;
+            backend?: Readonly<{
+                bindings: readonly import("@fungi.computer/puffball").AppBackendBinding[];
+                sync?: Readonly<{
+                    method: string;
+                }>;
+            }> | undefined;
+        }>, never, never>>;
+        readonly kind: Schema.Literal<"backend">;
+        readonly backend: Schema.Uint8ArrayFromBase64;
+    }>, Schema.Struct<{
+        readonly declaration: Schema.optionalKey<Schema.Codec<Readonly<{
+            api?: import("@fungi.computer/puffball").AppApi;
+            displayName?: string | undefined;
+            capabilities: readonly import("@fungi.computer/puffball").AppCapabilityId[];
+            calls?: readonly Readonly<{
+                appId: string;
+                methods: readonly string[];
+            }>[] | undefined;
+            guidance?: string | undefined;
+            handlers: readonly import("@fungi.computer/puffball").AppHandler[];
+            receives?: readonly "git.push"[] | undefined;
+            icon?: string;
+            roles: readonly import("@fungi.computer/puffball").AppRole[];
+            storage?: readonly import("@fungi.computer/puffball").AppStorageKey[] | undefined;
+            commands?: readonly import("@fungi.computer/puffball").AppDeclaredCommand[] | undefined;
+            gills?: readonly import("@fungi.computer/gills").AppDeclaredGill[] | undefined;
+            backend?: Readonly<{
+                bindings: readonly import("@fungi.computer/puffball").AppBackendBinding[];
+                sync?: Readonly<{
+                    method: string;
+                }>;
+            }> | undefined;
+        }>, Readonly<{
+            api?: import("@fungi.computer/puffball").AppApi;
+            displayName?: string | undefined;
+            capabilities: readonly import("@fungi.computer/puffball").AppCapabilityId[];
+            calls?: readonly Readonly<{
+                appId: string;
+                methods: readonly string[];
+            }>[] | undefined;
+            guidance?: string | undefined;
+            handlers: readonly import("@fungi.computer/puffball").AppHandler[];
+            receives?: readonly "git.push"[] | undefined;
+            icon?: string;
+            roles: readonly import("@fungi.computer/puffball").AppRole[];
+            storage?: readonly import("@fungi.computer/puffball").AppStorageKey[] | undefined;
+            commands?: readonly import("@fungi.computer/puffball").AppDeclaredCommand[] | undefined;
+            gills?: readonly import("@fungi.computer/gills").AppDeclaredGill[] | undefined;
+            backend?: Readonly<{
+                bindings: readonly import("@fungi.computer/puffball").AppBackendBinding[];
+                sync?: Readonly<{
+                    method: string;
+                }>;
+            }> | undefined;
+        }>, never, never>>;
+        readonly kind: Schema.Literal<"app">;
+        readonly ui: Schema.Union<readonly [Schema.Struct<{
+            readonly mediaType: Schema.Literal<"text/html; charset=utf-8">;
+            readonly content: Schema.Struct<{
+                readonly kind: Schema.Literal<"html">;
+                readonly bytes: Schema.Uint8ArrayFromBase64;
+            }>;
+        }>, Schema.Struct<{
+            readonly mediaType: Schema.Literal<"application/vnd.fungi.app-assets+json">;
+            readonly content: Schema.Struct<{
+                readonly kind: Schema.Literal<"assets">;
+                readonly base: Schema.String;
+                readonly assets: Schema.$Array<Schema.Struct<{
+                    readonly path: Schema.String;
+                    readonly bytes: Schema.Uint8ArrayFromBase64;
+                }>>;
+            }>;
+        }>]>;
+        readonly backend: Schema.Uint8ArrayFromBase64;
+    }>]>;
+    readonly provenance: Schema.Struct<{
+        readonly sourceRevision: Schema.refine<import("@fungi.computer/puffball").SourceRevision, Schema.String>;
+        readonly sourceTreeDigest: Schema.refine<import("@fungi.computer/puffball").Sha256Digest, Schema.String>;
+        readonly buildRecipeDigest: Schema.refine<import("@fungi.computer/puffball").Sha256Digest, Schema.String>;
+    }>;
+}>;
+/** One submitted Team App candidate. */
+export type TeamAppCandidateSubmission = Schema.Schema.Type<typeof teamAppCandidateSubmissionSchema>;
+/** One Team App candidate with its reserved Release ID. */
+export type PreparedTeamAppCandidate = Schema.Schema.Type<typeof preparedCandidateSchema>;
+/** Canonical wire bytes make TeamDO's same-request digest independent of JSON spacing. */
+export declare function encodeTeamAppCandidateSubmission(input: TeamAppCandidateSubmission): string;

package/dist/build/submission-contract.js

@@ -0,0 +1,70 @@
+import { assetBaseSchema, assetPathSchema, } from "@fungi.computer/puffball/assets";
+import { appIdSchema, releaseIdSchema, sha256DigestSchema, sourceRevisionSchema, } from "@fungi.computer/puffball/effect";
+import { appDeclarationSchema } from "@fungi.computer/puffball/app";
+import { backendJsonSchema } from "@fungi.computer/puffball/backend";
+import * as Schema from "effect/Schema";
+import { isSigilName } from "@fungi.computer/sigils";
+/** The largest Team App candidate submission request body, in bytes. */
+export const TEAM_APP_SUBMISSION_MAX_REQUEST_BYTES = 24 * 1024 * 1024;
+/** One uploaded byte string; the enclosing HTTP request has a separate total bound. */
+const bytesSchema = Schema.Uint8ArrayFromBase64.pipe(Schema.check(Schema.makeFilter((bytes) => bytes.byteLength <= 16 * 1024 * 1024)));
+const backendBytesSchema = bytesSchema.pipe(Schema.check(Schema.makeFilter((bytes) => Schema.decodeUnknownResult(backendJsonSchema)(new TextDecoder().decode(bytes), { onExcessProperty: "error" })._tag === "Success")));
+const uiOutputSchema = Schema.Union([
+    Schema.Struct({
+        mediaType: Schema.Literal("text/html; charset=utf-8"),
+        content: Schema.Struct({
+            kind: Schema.Literal("html"),
+            bytes: bytesSchema,
+        }),
+    }),
+    Schema.Struct({
+        mediaType: Schema.Literal("application/vnd.fungi.app-assets+json"),
+        content: Schema.Struct({
+            kind: Schema.Literal("assets"),
+            base: assetBaseSchema,
+            assets: Schema.Array(Schema.Struct({ path: assetPathSchema, bytes: bytesSchema })),
+        }),
+    }),
+]);
+/** A request only; the Team's installation grants remain the authority. */
+const declaration = {
+    declaration: Schema.optionalKey(appDeclarationSchema.check(Schema.makeFilter((declaration) => declaration.icon === undefined || isSigilName(declaration.icon), { message: "App icon must name a registered Sigil" }))),
+};
+const outputSchema = Schema.Union([
+    Schema.Struct({
+        kind: Schema.Literal("ui"),
+        ui: uiOutputSchema,
+        ...declaration,
+    }),
+    Schema.Struct({
+        kind: Schema.Literal("backend"),
+        backend: backendBytesSchema,
+        ...declaration,
+    }),
+    Schema.Struct({
+        kind: Schema.Literal("app"),
+        ui: uiOutputSchema,
+        backend: backendBytesSchema,
+        ...declaration,
+    }),
+]);
+const candidateFields = {
+    appId: appIdSchema,
+    output: outputSchema,
+    provenance: Schema.Struct({
+        sourceRevision: sourceRevisionSchema,
+        sourceTreeDigest: sha256DigestSchema,
+        buildRecipeDigest: sha256DigestSchema,
+    }),
+};
+/** Exact submitted output and provenance before the Team assigns a stable Release ID. */
+export const teamAppCandidateSubmissionSchema = Schema.Struct(candidateFields);
+/** Publisher persistence input after TeamDO reserves retry-stable identities. */
+export const preparedCandidateSchema = Schema.Struct({
+    ...candidateFields,
+    releaseId: releaseIdSchema,
+});
+/** Canonical wire bytes make TeamDO's same-request digest independent of JSON spacing. */
+export function encodeTeamAppCandidateSubmission(input) {
+    return JSON.stringify(Schema.encodeUnknownSync(teamAppCandidateSubmissionSchema)(input));
+}

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

@@ -0,0 +1,50 @@
+import * as Schema from "effect/Schema";
+import type { WorkspaceBuildStep } from "./build-step.js";
+/**
+ * `package.json#fungi.build`. An App manifest (the manifest nearest the
+ * entry) declares how its page builds: `react`, `shellEntry`, the workspace
+ * packages whose declared stylesheets compile first (`packageStylesheets`)
+ * and its own `stylesheets`, compiled in place, in order. A workspace
+ * package declares its build products: extra TypeScript configs compiled
+ * after its `tsconfig.build.json`, and its stylesheet input and output.
+ * Every path is relative to the manifest that declares it.
+ */
+export declare const workspaceBuildPolicySchema: Schema.Struct<{
+    readonly react: Schema.optional<Schema.Boolean>;
+    readonly shellEntry: Schema.optional<Schema.String>;
+    readonly packageStylesheets: Schema.optional<Schema.$Array<Schema.String>>;
+    readonly stylesheets: Schema.optional<Schema.$Array<Schema.String>>;
+    readonly typescript: Schema.optional<Schema.$Array<Schema.String>>;
+    readonly stylesheet: Schema.optional<Schema.Struct<{
+        readonly input: Schema.String;
+        readonly output: Schema.String;
+    }>>;
+}>;
+/** The build policy one manifest declares. */
+export type WorkspaceBuildPolicy = Schema.Schema.Type<typeof workspaceBuildPolicySchema>;
+/** The pnpm arguments that list a source tree's workspace projects. */
+export declare const workspaceProjectsArguments: readonly string[];
+/** One App page build derived from its manifests and package graph. */
+export type WorkspaceBuild = Readonly<{
+    /** The pnpm workspace that owns the entry, relative to the source root. */
+    directory: string;
+    packageName: string;
+    react: boolean;
+    /** A shell module entry, relative to `directory`. */
+    shellEntry?: string;
+    /** The workspace's runtime workspace dependencies, dependencies first. */
+    dependencies: readonly string[];
+    steps: readonly WorkspaceBuildStep[];
+}>;
+/**
+ * Derive one App's page build from the captured source alone: the manifest
+ * nearest `entry` declares the App policy, the owning pnpm workspace's
+ * runtime `workspace:` dependencies give the compile order, and each
+ * dependency's manifest declares its own extra build products.
+ */
+export declare function resolveWorkspaceBuild(options: {
+    readonly root: string;
+    readonly entry: string;
+    /** `pnpm ls -r --depth -1 --json` output for the same source tree. */
+    readonly projects: string;
+}): Promise<WorkspaceBuild>;

package/dist/build/workspace-build.js

@@ -0,0 +1,156 @@
+import { access, readFile } from "node:fs/promises";
+import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import * as Schema from "effect/Schema";
+const manifestPathSchema = Schema.String.pipe(Schema.check(Schema.makeFilter((path) => path.length > 0 &&
+    !path.startsWith("/") &&
+    !path.includes("\\") &&
+    path
+        .split("/")
+        .every((part) => part !== "" && part !== "." && part !== ".."))));
+/**
+ * `package.json#fungi.build`. An App manifest (the manifest nearest the
+ * entry) declares how its page builds: `react`, `shellEntry`, the workspace
+ * packages whose declared stylesheets compile first (`packageStylesheets`)
+ * and its own `stylesheets`, compiled in place, in order. A workspace
+ * package declares its build products: extra TypeScript configs compiled
+ * after its `tsconfig.build.json`, and its stylesheet input and output.
+ * Every path is relative to the manifest that declares it.
+ */
+export const workspaceBuildPolicySchema = Schema.Struct({
+    react: Schema.optional(Schema.Boolean),
+    shellEntry: Schema.optional(manifestPathSchema),
+    packageStylesheets: Schema.optional(Schema.Array(Schema.String)),
+    stylesheets: Schema.optional(Schema.Array(manifestPathSchema)),
+    typescript: Schema.optional(Schema.Array(manifestPathSchema)),
+    stylesheet: Schema.optional(Schema.Struct({ input: manifestPathSchema, output: manifestPathSchema })),
+});
+const manifestSchema = Schema.fromJsonString(Schema.Struct({
+    name: Schema.optional(Schema.String),
+    dependencies: Schema.optional(Schema.Record(Schema.String, Schema.String)),
+    fungi: Schema.optional(Schema.Struct({ build: Schema.optional(workspaceBuildPolicySchema) })),
+}));
+/** One pnpm workspace project, as `pnpm ls -r --depth -1 --json` lists it. */
+const workspaceProjectsSchema = Schema.fromJsonString(Schema.Array(Schema.Struct({
+    name: Schema.String.pipe(Schema.check(Schema.isMinLength(1))),
+    path: Schema.String.pipe(Schema.check(Schema.isMinLength(1))),
+})));
+/** The pnpm arguments that list a source tree's workspace projects. */
+export const workspaceProjectsArguments = Object.freeze([
+    "ls",
+    "--recursive",
+    "--depth",
+    "-1",
+    "--json",
+]);
+function within(root, path) {
+    const relativePath = relative(root, resolve(root, path));
+    if (relativePath === ".." ||
+        relativePath.startsWith(`..${sep}`) ||
+        isAbsolute(relativePath))
+        throw new Error(`Build input escapes the captured source: ${path}`);
+    return relativePath.split(sep).join("/");
+}
+async function exists(path) {
+    return access(path).then(() => true, () => false);
+}
+/**
+ * Derive one App's page build from the captured source alone: the manifest
+ * nearest `entry` declares the App policy, the owning pnpm workspace's
+ * runtime `workspace:` dependencies give the compile order, and each
+ * dependency's manifest declares its own extra build products.
+ */
+export async function resolveWorkspaceBuild(options) {
+    const root = resolve(options.root);
+    const entry = within(root, options.entry);
+    const manifests = new Map();
+    const manifest = async (directory) => {
+        const known = manifests.get(directory);
+        if (known)
+            return known;
+        const decoded = Schema.decodeUnknownSync(manifestSchema)(await readFile(join(root, directory, "package.json"), "utf8"));
+        manifests.set(directory, decoded);
+        return decoded;
+    };
+    const projects = new Map();
+    for (const project of Schema.decodeUnknownSync(workspaceProjectsSchema)(options.projects)) {
+        const directory = within(root, project.path);
+        if (directory === "")
+            continue;
+        if (projects.has(project.name))
+            throw new Error(`Workspace package name repeats: ${project.name}`);
+        projects.set(project.name, directory);
+    }
+    const owners = [...projects]
+        .filter(([, directory]) => entry.startsWith(`${directory}/`))
+        .sort(([, left], [, right]) => right.length - left.length);
+    const owner = owners[0];
+    if (!owner)
+        throw new Error(`No workspace package owns ${entry}`);
+    const [packageName, directory] = owner;
+    let appDirectory = dirname(entry);
+    while (appDirectory !== directory &&
+        !(await exists(join(root, appDirectory, "package.json"))))
+        appDirectory = dirname(appDirectory);
+    const policy = (await manifest(appDirectory)).fungi?.build ?? {};
+    const dependencies = [];
+    const visiting = new Set([directory]);
+    const visit = async (from) => {
+        for (const [name, range] of Object.entries((await manifest(from)).dependencies ?? {})) {
+            if (!range.startsWith("workspace:"))
+                continue;
+            const dependency = projects.get(name);
+            if (dependency === undefined)
+                throw new Error(`${from} depends on an unlisted workspace ${name}`);
+            if (dependencies.includes(dependency))
+                continue;
+            if (visiting.has(dependency))
+                throw new Error(`Workspace dependency cycle through ${name}`);
+            visiting.add(dependency);
+            await visit(dependency);
+            visiting.delete(dependency);
+            dependencies.push(dependency);
+        }
+    };
+    await visit(directory);
+    const steps = [];
+    for (const dependency of dependencies) {
+        if (await exists(join(root, dependency, "tsconfig.build.json")))
+            steps.push({
+                kind: "typescript",
+                config: `${dependency}/tsconfig.build.json`,
+            });
+        for (const config of (await manifest(dependency)).fungi?.build
+            ?.typescript ?? [])
+            steps.push({ kind: "typescript", config: `${dependency}/${config}` });
+    }
+    for (const name of policy.packageStylesheets ?? []) {
+        const owner = projects.get(name);
+        if (owner === undefined || !dependencies.includes(owner))
+            throw new Error(`Stylesheet package ${name} is not a workspace dependency`);
+        const declared = (await manifest(owner)).fungi?.build?.stylesheet;
+        if (!declared)
+            throw new Error(`${name} declares no stylesheet`);
+        steps.push({
+            kind: "tailwind",
+            input: `${owner}/${declared.input}`,
+            output: `${owner}/${declared.output}`,
+        });
+    }
+    for (const stylesheet of policy.stylesheets ?? []) {
+        const path = within(root, join(appDirectory, stylesheet));
+        steps.push({ kind: "tailwind", input: path, output: path });
+    }
+    const build = {
+        directory,
+        packageName,
+        react: policy.react === true,
+        dependencies: Object.freeze(dependencies),
+        steps: Object.freeze(steps),
+    };
+    if (policy.shellEntry === undefined)
+        return Object.freeze(build);
+    const shellEntry = relative(join(root, directory), join(root, appDirectory, policy.shellEntry))
+        .split(sep)
+        .join("/");
+    return Object.freeze({ ...build, shellEntry });
+}

package/dist/build-contract.d.ts

@@ -0,0 +1,4 @@
+/** Provider-neutral App build recipes and candidate orchestration. */
+export * from "./build/effect.js";
+/** Team App candidate wire contract: submission schema and codec. */
+export * from "./build/submission-contract.js";