@fungi.computer/oyster 0.0.0-stage → 0.1.0

package/dist/build/effect.js

@@ -0,0 +1,436 @@
+import { assetBuildPolicySchema, assetBaseSchema, } from "@fungi.computer/puffball/assets";
+import { boundedBundlePolicy, bundledHtmlRecipe } from "./html-recipe.js";
+import { workspaceBuildPolicy } from "./build-policy.js";
+import * as crypto from "node:crypto";
+import { backendJsonSchema, durableBackendSchema, } from "@fungi.computer/puffball/backend";
+import { parseSha256Digest, } from "@fungi.computer/puffball";
+import { appIdSchema } from "@fungi.computer/puffball/effect";
+import * as Effect from "effect/Effect";
+import * as Schema from "effect/Schema";
+const relativeEntrySchema = Schema.String.pipe(Schema.check(Schema.isMinLength(1)), Schema.check(Schema.makeFilter((entry) => {
+    if (entry.startsWith("/") || entry.includes("\\"))
+        return false;
+    return entry
+        .split("/")
+        .every((part) => part !== "" && part !== "." && part !== "..");
+})));
+/** Canonical recipe policy shared by core and the local adapter. */
+export const pinnedRecipeSchema = Schema.Struct({
+    kind: Schema.optional(Schema.Literals(["bundled-html", "source-html"])),
+    entry: relativeEntrySchema,
+    assets: Schema.optional(assetBuildPolicySchema),
+    assetBase: Schema.optionalKey(assetBaseSchema),
+    backend: Schema.Union([
+        Schema.Null,
+        Schema.Struct({
+            entry: Schema.optional(relativeEntrySchema),
+            runtime: durableBackendSchema.fields.runtime,
+            compatibilityDate: durableBackendSchema.fields.compatibilityDate,
+            exportName: durableBackendSchema.fields.exportName,
+        }),
+    ]),
+    maxOutputBytes: Schema.Number.pipe(Schema.check(Schema.isInt()), Schema.check(Schema.makeFilter((value) => Number.isFinite(value))), Schema.check(Schema.isGreaterThan(0))),
+});
+/** Core configuration contains only immutable App identity and recipe policy. */
+export const AppPublisherCoreConfigSchema = Schema.Struct({
+    appId: appIdSchema,
+    recipe: pinnedRecipeSchema,
+});
+const esmToolchain = Object.freeze({ esbuild: "0.28.2" });
+const sourceHtmlToolchain = Object.freeze({
+    ...esmToolchain,
+    node: "24.20.0",
+    npm: "11.19.0",
+    vite: "8.2.2",
+    pluginReact: "6.1.1",
+    recipe: "captured-npm-source-html-v1",
+    packageResolution: "captured-browser-module-main-v1",
+});
+/**
+ * The one pinned toolchain for an App page captured with its pnpm workspace.
+ * The App's own manifest declares its page policy and the package graph
+ * orders its dependency builds, so both are pinned by the source tree digest.
+ */
+const workspaceHtmlToolchain = Object.freeze({
+    node: "24.20.0",
+    pnpm: "11.24.0",
+    vite: "8.2.2",
+    pluginReact: "6.1.1",
+    singlefile: "2.3.3",
+    react: "18.3.1",
+    typescript: "5.9.3",
+    tailwindcss: "4.2.1",
+    tailwindNode: "4.2.1",
+    tailwindOxide: "4.2.1",
+    tailwindResolver: "5.24.5",
+    typography: "0.5.19",
+    buildPolicy: workspaceBuildPolicy,
+    recipe: "captured-workspace-html-v1",
+});
+const workspaceHtmlBackendToolchain = Object.freeze({
+    ...workspaceHtmlToolchain,
+    ...esmToolchain,
+    packageResolution: "captured-browser-module-main-v1",
+});
+/** Package-export conditions used by the pinned Workers builder. */
+export const appBackendExportConditions = Object.freeze([
+    "workerd",
+    "worker",
+    "browser",
+]);
+/** Persisted, fully resolved recipe including its code-owned toolchain. */
+export const capturedPinnedRecipeSchema = Schema.Struct({
+    kind: pinnedRecipeSchema.fields.kind,
+    bundle: Schema.Literal(true),
+    entry: relativeEntrySchema,
+    format: Schema.Literals(["html", "esm", "assets"]),
+    assets: Schema.optional(assetBuildPolicySchema),
+    assetBase: Schema.optionalKey(assetBaseSchema),
+    toolchain: Schema.Record(Schema.String, Schema.String),
+    maxOutputBytes: Schema.Number.pipe(Schema.check(Schema.isInt()), Schema.check(Schema.isGreaterThan(0))),
+    platform: Schema.Literals(["browser", "neutral"]),
+    backend: pinnedRecipeSchema.fields.backend,
+    target: Schema.Tuple([Schema.Literal("es2022")]),
+});
+/** Closed failure boundary for the four private composition stages. */
+export class AppPublisherError extends Error {
+    stage;
+    _tag = "AppPublisherError";
+    constructor(stage, options) {
+        super(`App Publisher ${stage} stage failed`, options);
+        this.stage = stage;
+        this.name = this._tag;
+    }
+}
+function sha256Digest(value) {
+    return parseSha256Digest(`sha256:${crypto.createHash("sha256").update(value, "utf8").digest("hex")}`);
+}
+/** The toolchain this Publisher pins for a recipe of this kind, entry and backend. */
+function currentToolchain(recipe) {
+    if (recipe.kind === "source-html")
+        return sourceHtmlToolchain;
+    if (recipe.kind === bundledHtmlRecipe.kind)
+        return recipe.backend === null
+            ? bundledHtmlRecipe.toolchain
+            : { ...bundledHtmlRecipe.toolchain, ...esmToolchain, pnpm: "11.24.0" };
+    if (recipe.entry.endsWith(".html"))
+        return recipe.backend === null
+            ? workspaceHtmlToolchain
+            : workspaceHtmlBackendToolchain;
+    return esmToolchain;
+}
+/**
+ * Whether a pinned recipe pins this Publisher's current toolchain (its build
+ * policy included). An executor refuses any other: a recipe pinned under
+ * another policy describes a build this code does not perform.
+ */
+export function pinsCurrentToolchain(recipe) {
+    const entries = (toolchain) => JSON.stringify(Object.entries(toolchain).sort(([a], [b]) => a.localeCompare(b)));
+    return entries(currentToolchain(recipe)) === entries(recipe.toolchain);
+}
+function captureConfig(input) {
+    let decoded;
+    try {
+        decoded = Schema.decodeUnknownSync(AppPublisherCoreConfigSchema)(input);
+    }
+    catch {
+        throw new AppPublisherError("configuration");
+    }
+    const bundled = decoded.recipe.kind === bundledHtmlRecipe.kind;
+    const sourceHtml = decoded.recipe.kind === "source-html";
+    // Any other HTML entry is a page built with its own pnpm workspace; the
+    // App's manifest, read from the captured source, declares how.
+    const workspaceHtml = decoded.recipe.kind === undefined && decoded.recipe.entry.endsWith(".html");
+    const html = workspaceHtml || bundled || sourceHtml;
+    if (sourceHtml &&
+        (!decoded.recipe.entry.endsWith(".html") ||
+            !decoded.recipe.assets ||
+            !boundedBundlePolicy(decoded.recipe.assets, decoded.recipe.maxOutputBytes)))
+        throw new AppPublisherError("configuration");
+    if (bundled) {
+        const policy = decoded.recipe.assets;
+        if (!policy ||
+            !decoded.recipe.entry.endsWith("/index.html") ||
+            !boundedBundlePolicy(policy, decoded.recipe.maxOutputBytes))
+            throw new AppPublisherError("configuration");
+    }
+    if ((html &&
+        decoded.recipe.backend !== null &&
+        decoded.recipe.backend.entry === undefined) ||
+        (!html && decoded.recipe.backend?.entry !== undefined))
+        throw new AppPublisherError("configuration");
+    if (decoded.recipe.assets && !html)
+        throw new AppPublisherError("configuration");
+    if (Boolean(decoded.recipe.assets) !==
+        (decoded.recipe.assetBase !== undefined))
+        throw new AppPublisherError("configuration");
+    const recipeBase = {
+        bundle: true,
+        entry: decoded.recipe.entry,
+        format: decoded.recipe.assets
+            ? "assets"
+            : workspaceHtml
+                ? "html"
+                : "esm",
+        toolchain: currentToolchain(decoded.recipe),
+        maxOutputBytes: decoded.recipe.maxOutputBytes,
+        platform: decoded.recipe.backend === null
+            ? "browser"
+            : "neutral",
+        backend: decoded.recipe.backend,
+        target: ["es2022"],
+    };
+    const resolvedBase = decoded.recipe.kind !== undefined
+        ? { ...recipeBase, kind: decoded.recipe.kind }
+        : recipeBase;
+    const recipe = Object.freeze(decoded.recipe.assets && decoded.recipe.assetBase !== undefined
+        ? {
+            ...resolvedBase,
+            assets: Object.freeze({ ...decoded.recipe.assets }),
+            assetBase: decoded.recipe.assetBase,
+        }
+        : resolvedBase);
+    return Object.freeze({
+        appId: decoded.appId,
+        recipe,
+        buildRecipeDigest: digestPinnedRecipe(recipe),
+    });
+}
+/** Hash every captured build and output-policy input in the Publisher recipe. */
+export function digestPinnedRecipe(recipe) {
+    const buildMaterial = {
+        bundle: recipe.bundle,
+        entry: recipe.entry,
+        format: recipe.format,
+        toolchain: recipe.toolchain,
+    };
+    const outputPolicy = {
+        maxOutputBytes: recipe.maxOutputBytes,
+        backendMinify: recipe.backend !== null,
+        platform: recipe.platform,
+        backend: recipe.backend,
+        target: recipe.target,
+    };
+    const outputMaterial = recipe.backend === null
+        ? outputPolicy
+        : { ...outputPolicy, conditions: appBackendExportConditions };
+    const vite = {
+        configFile: false,
+        envDir: false,
+        envPrefix: [],
+        cssCodeSplit: recipe.format === "assets",
+        inlineDynamicImports: recipe.format !== "assets",
+        assetsInlineLimit: recipe.format === "assets" ? 0 : recipe.maxOutputBytes,
+        output: recipe.format === "assets"
+            ? "immutable-asset-build"
+            : "one-complete-html",
+        css: "compiled-public-caps-stipe",
+        dependencyInputs: "contained-before-probe-typescript-host-tailwind-core-loaders",
+        subprocesses: "owned-process-group-term-kill-5-seconds",
+    };
+    const recipeVite = recipe.assets
+        ? {
+            ...vite,
+            assetPolicy: recipe.assets,
+            base: recipe.assetBase,
+            cssUrls: "tailwind-node-4.2.1-after-contained-root-check",
+        }
+        : vite;
+    const recipeMaterial = JSON.stringify(recipe.kind === bundledHtmlRecipe.kind
+        ? {
+            ...buildMaterial,
+            ...outputMaterial,
+            bundledHtmlRecipe,
+            assetPolicy: recipe.assets,
+            base: recipe.assetBase,
+        }
+        : recipe.format !== "esm"
+            ? {
+                ...buildMaterial,
+                hydration: {
+                    frozenLockfile: true,
+                    ignoreScripts: true,
+                    ignorePnpmfile: true,
+                    packageImportMethod: "auto",
+                    store: "snapshot-local",
+                    virtualStore: "snapshot-local",
+                    environment: "tool-path-only-snapshot-home-no-user-or-global-npmrc",
+                },
+                vite: recipeVite,
+                ...outputMaterial,
+            }
+            : { ...buildMaterial, ...outputMaterial });
+    return sha256Digest(recipeMaterial);
+}
+/** Decode and normalize Publisher-owned recipe policy for durable seed proof. */
+export function normalizeAppPublisherRecipe(input) {
+    const captured = captureConfig(input);
+    return Object.freeze({
+        recipe: captured.recipe,
+        buildRecipeDigest: captured.buildRecipeDigest,
+    });
+}
+function createReleaseBoundary(catalog, release) {
+    return Effect.tryPromise({
+        try: () => catalog.createRelease(release),
+        catch: () => new AppPublisherError("release"),
+    });
+}
+function stageFailure(stage) {
+    return new AppPublisherError(stage);
+}
+function prepareUiOutput(output, recipe) {
+    switch (output.kind) {
+        case "bytes":
+            return recipe.format === "html" &&
+                output.bytes.byteLength <= recipe.maxOutputBytes
+                ? {
+                    content: { kind: "html", bytes: output.bytes },
+                    mediaType: "text/html; charset=utf-8",
+                }
+                : undefined;
+        case "assets":
+            return recipe.format === "assets" && output.base === recipe.assetBase
+                ? {
+                    content: output,
+                    mediaType: "application/vnd.fungi.app-assets+json",
+                }
+                : undefined;
+    }
+}
+function validPreparedUiOutput(ui, recipe) {
+    switch (ui.content.kind) {
+        case "html":
+            return (ui.mediaType === "text/html; charset=utf-8" &&
+                ui.content.bytes.byteLength <= recipe.maxOutputBytes);
+        case "assets":
+            return (ui.mediaType === "application/vnd.fungi.app-assets+json" &&
+                recipe.assets !== undefined &&
+                ui.content.base === recipe.assetBase);
+    }
+}
+function encodeBackendOutput(bytes, recipe) {
+    if (recipe.backend === null)
+        return Effect.fail(stageFailure("build"));
+    return Schema.encodeEffect(backendJsonSchema)({
+        ...recipe.backend,
+        code: new TextDecoder().decode(bytes),
+    }).pipe(Effect.map((encoded) => new TextEncoder().encode(encoded)), Effect.filterOrFail((encoded) => encoded.byteLength <= recipe.maxOutputBytes, () => stageFailure("build")), Effect.mapError(() => stageFailure("build")));
+}
+/**
+ * The largest single object a build under this recipe may upload: no larger
+ * than the largest output bound the recipe could assign it under.
+ */
+export function pinnedRecipeObjectBound(recipe) {
+    return Math.max(recipe.maxOutputBytes, recipe.assets?.maxObjectBytes ?? 0);
+}
+/**
+ * Whether output built elsewhere (a Computer's candidate manifest) is one
+ * this recipe could assign: the same surfaces and `maxOutputBytes` bound the
+ * preparer applies here. Asset sizes stay the artifact writer's policy.
+ */
+export function fitsPinnedRecipe(output, recipe) {
+    const uiFits = (ui) => ui.content.kind === "html"
+        ? ui.content.byteLength <= recipe.maxOutputBytes
+        : recipe.assets !== undefined && ui.content.base === recipe.assetBase;
+    const backendFits = (backend) => recipe.backend !== null && backend.byteLength <= recipe.maxOutputBytes;
+    switch (output.kind) {
+        case "ui":
+            return recipe.backend === null && uiFits(output.ui);
+        case "backend":
+            return backendFits(output.backend);
+        case "app":
+            return uiFits(output.ui) && backendFits(output.backend);
+    }
+}
+function assignAppOutput(built, recipe) {
+    switch (built.kind) {
+        case "bytes":
+        case "assets":
+            return assignRawOutput(built, recipe);
+        case "app":
+            return assignJoinedOutput(built, recipe);
+    }
+}
+function assignRawOutput(built, recipe) {
+    const ui = prepareUiOutput(built, recipe);
+    if (recipe.backend === null)
+        return ui === undefined
+            ? Effect.fail(stageFailure("build"))
+            : Effect.succeed({ kind: "ui", ui });
+    if (built.kind !== "bytes")
+        return Effect.fail(stageFailure("build"));
+    return encodeBackendOutput(built.bytes, recipe).pipe(Effect.map((backend) => ({ kind: "backend", backend })));
+}
+function assignJoinedOutput(built, recipe) {
+    const ui = built.ui;
+    if (ui !== null && !validPreparedUiOutput(ui, recipe))
+        return Effect.fail(stageFailure("build"));
+    if (built.backend === null) {
+        if (ui === null || recipe.backend !== null)
+            return Effect.fail(stageFailure("build"));
+        return Effect.succeed({ kind: "ui", ui });
+    }
+    return encodeBackendOutput(built.backend, recipe).pipe(Effect.map((backend) => ui === null ? { kind: "backend", backend } : { kind: "app", ui, backend }));
+}
+/** Construct one private App Publisher with copied core configuration and roles. */
+export function createAppCandidatePreparer(options) {
+    return createCapturedCandidatePreparer(captureConfig(options.config), options);
+}
+/** Prepare a candidate from a previously captured recipe. */
+export function createCapturedCandidatePreparer(config, options) {
+    const { sourceCapture, buildExecutor } = options;
+    const prepareCandidate = (releaseId) => Effect.scoped(Effect.gen(function* () {
+        const source = yield* sourceCapture
+            .capture()
+            .pipe(Effect.mapError(() => stageFailure("source")));
+        const built = yield* buildExecutor
+            .build(source, config.recipe)
+            .pipe(Effect.mapError((error) => new AppPublisherError("build", { cause: error })));
+        const assigned = yield* assignAppOutput(built, config.recipe);
+        const declaration = buildExecutor.declaration === undefined
+            ? undefined
+            : yield* buildExecutor
+                .declaration(source, config.recipe)
+                .pipe(Effect.mapError((error) => new AppPublisherError("build", { cause: error })));
+        const output = declaration === undefined ? assigned : { ...assigned, declaration };
+        return {
+            appId: config.appId,
+            releaseId,
+            output,
+            provenance: {
+                sourceRevision: source.sourceRevision,
+                sourceTreeDigest: source.sourceTreeDigest,
+                buildRecipeDigest: config.buildRecipeDigest,
+            },
+        };
+    }));
+    return Object.freeze({ prepareCandidate });
+}
+/** Persist a prepared build through the native artifact and App Release owners. */
+export function commitPreparedCandidate(prepared, options) {
+    return Effect.gen(function* () {
+        const stored = yield* options.artifactWriter
+            .write(prepared.output)
+            .pipe(Effect.mapError(() => stageFailure("artifact")));
+        const release = {
+            releaseId: prepared.releaseId,
+            appId: prepared.appId,
+            artifact: {
+                artifactRef: stored.artifactRef,
+                artifactDigest: stored.artifactDigest,
+                provenance: prepared.provenance,
+            },
+        };
+        return yield* createReleaseBoundary(options.releaseCatalog, release);
+    });
+}
+/** Compose capture, compilation, immutable writing and Release recording. */
+export function createAppPublisher(options) {
+    const preparer = createAppCandidatePreparer(options);
+    const createCandidate = (releaseId) => preparer.prepareCandidate(releaseId).pipe(Effect.flatMap((prepared) => commitPreparedCandidate(prepared, {
+        artifactWriter: options.artifactWriter,
+        releaseCatalog: options.releaseCatalog,
+    })));
+    return Object.freeze({ createCandidate });
+}

package/dist/build/git-environment.d.ts

@@ -0,0 +1,9 @@
+/** Run a nested repository without inheriting the caller's Git checkout. */
+export declare function repositoryEnvironment(): NodeJS.ProcessEnv;
+/** Git environment carrying host-held request headers (credentials) only in
+ * Git's own config environment: never argv, a URL or a trace. */
+export declare function authenticatedGitEnvironment(headers: Readonly<Record<string, string>>): NodeJS.ProcessEnv;
+/** Git environment for one authenticated Artifacts fetch; caller validates token. */
+export declare function artifactsGitEnvironment(token: string): NodeJS.ProcessEnv;
+/** Credential-free private route used by the hosted Publisher Git client. */
+export declare function hostedArtifactsGitRemote(endpoint: string, repository: string): string;

package/dist/build/git-environment.js

@@ -0,0 +1,60 @@
+/** Run a nested repository without inheriting the caller's Git checkout. */
+export function repositoryEnvironment() {
+    return Object.fromEntries(Object.entries(process.env).filter(([name]) => !name.startsWith("GIT_")));
+}
+/** Git environment carrying host-held request headers (credentials) only in
+ * Git's own config environment: never argv, a URL or a trace. */
+export function authenticatedGitEnvironment(headers) {
+    const excludedEnvironmentNames = new Set([
+        "GIT_CURL_VERBOSE",
+        "CLOUDFLARE_API_TOKEN",
+        "ARTIFACTS_API_TOKEN",
+        "ARTIFACTS_REPO_TOKEN",
+        "ARTIFACTS_TOKEN",
+    ]);
+    const environment = Object.fromEntries(Object.entries(repositoryEnvironment()).filter(([name]) => !name.startsWith("GIT_TRACE") && !excludedEnvironmentNames.has(name)));
+    for (const [name, value] of Object.entries(headers))
+        if (!/^[A-Za-z0-9-]+$/u.test(name) || /[\r\n\0]/u.test(value))
+            throw new Error("Git request header is invalid");
+    // An empty first value resets any inherited extra headers.
+    const config = [
+        ["http.extraHeader", ""],
+        ...Object.entries(headers).map(([name, value]) => ["http.extraHeader", `${name}: ${value}`]),
+        ["http.followRedirects", "false"],
+    ];
+    return {
+        ...environment,
+        ...Object.fromEntries(config.flatMap(([key, value], index) => [
+            [`GIT_CONFIG_KEY_${String(index)}`, key],
+            [`GIT_CONFIG_VALUE_${String(index)}`, value],
+        ])),
+        GIT_CONFIG_COUNT: String(config.length),
+        GIT_TRACE: "0",
+        GIT_TRACE_CURL: "0",
+    };
+}
+/** Git environment for one authenticated Artifacts fetch; caller validates token. */
+export function artifactsGitEnvironment(token) {
+    return authenticatedGitEnvironment({ Authorization: `Bearer ${token}` });
+}
+/** Credential-free private route used by the hosted Publisher Git client. */
+export function hostedArtifactsGitRemote(endpoint, repository) {
+    if (!/^[a-zA-Z0-9._-]{1,128}$/.test(repository))
+        throw new Error("Artifacts repository is invalid");
+    let base;
+    try {
+        base = new URL(endpoint);
+    }
+    catch (cause) {
+        throw new Error("Publisher endpoint is invalid", { cause });
+    }
+    const localHttp = base.protocol === "http:" &&
+        (base.hostname === "localhost" || base.hostname === "127.0.0.1");
+    if ((base.protocol !== "https:" && !localHttp) ||
+        base.username.length > 0 ||
+        base.password.length > 0 ||
+        base.search.length > 0 ||
+        base.hash.length > 0)
+        throw new Error("Publisher endpoint is invalid");
+    return new URL(`/v1/artifacts/git/${encodeURIComponent(repository)}.git`, base).toString();
+}

package/dist/build/html-recipe.d.ts

@@ -0,0 +1,20 @@
+import type { AssetBuildPolicy } from "@fungi.computer/puffball/assets";
+/** Engine/toolchain-independent input: an already bundled, captured directory.
+ * The producer owns compilation; Publisher never discovers its build scripts.
+ * These ceilings cannot be raised by a publication request.
+ */
+export declare const bundledHtmlRecipe: Readonly<{
+    kind: "bundled-html";
+    toolchain: Readonly<{
+        recipe: "captured-bundled-html-v1";
+    }>;
+    limits: Readonly<{
+        maxManifestBytes: 1048576;
+        maxObjects: 1024;
+        maxObjectBytes: 16777216;
+        maxTotalBytes: 67108864;
+    }>;
+    extensions: readonly string[];
+}>;
+/** Requests may tighten the catalog bounds, never raise them. */
+export declare function boundedBundlePolicy(policy: AssetBuildPolicy, maxOutputBytes: number): boolean;

package/dist/build/html-recipe.js

@@ -0,0 +1,51 @@
+/** Engine/toolchain-independent input: an already bundled, captured directory.
+ * The producer owns compilation; Publisher never discovers its build scripts.
+ * These ceilings cannot be raised by a publication request.
+ */
+export const bundledHtmlRecipe = Object.freeze({
+    kind: "bundled-html",
+    toolchain: Object.freeze({ recipe: "captured-bundled-html-v1" }),
+    limits: Object.freeze({
+        maxManifestBytes: 1_048_576,
+        maxObjects: 1024,
+        maxObjectBytes: 16_777_216,
+        maxTotalBytes: 67_108_864,
+    }),
+    extensions: Object.freeze([
+        ".html",
+        ".js",
+        ".mjs",
+        ".css",
+        ".json",
+        ".gz",
+        ".wasm",
+        ".png",
+        ".jpg",
+        ".jpeg",
+        ".webp",
+        ".avif",
+        ".gif",
+        ".svg",
+        ".ico",
+        ".woff",
+        ".woff2",
+        ".ttf",
+        ".otf",
+        ".mp3",
+        ".ogg",
+        ".wav",
+        ".mp4",
+        ".webm",
+        ".txt",
+    ]),
+});
+/** Requests may tighten the catalog bounds, never raise them. */
+export function boundedBundlePolicy(policy, maxOutputBytes) {
+    const limits = bundledHtmlRecipe.limits;
+    return (maxOutputBytes <= limits.maxTotalBytes &&
+        policy.maxTotalBytes <= maxOutputBytes &&
+        policy.maxManifestBytes <= limits.maxManifestBytes &&
+        policy.maxObjects <= limits.maxObjects &&
+        policy.maxObjectBytes <= limits.maxObjectBytes &&
+        policy.maxTotalBytes <= limits.maxTotalBytes);
+}

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

@@ -0,0 +1,67 @@
+import { type DefinitionEmission } from "./definition-emission.js";
+import { type AssetBuildPolicy } from "@fungi.computer/puffball/assets";
+import { parseSha256Digest, type AppId, type SourceRevision } from "@fungi.computer/puffball";
+import * as Effect from "effect/Effect";
+import * as esbuild from "esbuild";
+import { type AppPublisher, type ArtifactWriter, type BuildExecutor, type CapturedSource, type PinnedRecipe, type ReleaseCreator, type SourceCapture } from "./effect.js";
+/** Local proving adapter; accepted source policy is intentionally fixed to main. */
+export declare function createLocalSourceCapture(repositoryPath: string): SourceCapture;
+/** Capture saved App files for local authoring without modifying the customer's
+ * repository. Provenance names the exact temporary Git snapshot, not an existing
+ * customer commit. Dependencies and local credentials are not source inputs.
+ */
+export declare function createLocalDirectorySourceCapture(directory: string): SourceCapture;
+/** Capture an exact Artifacts commit through a trusted host's credential-free Git URL. */
+export declare function createArtifactsSourceCapture(options: {
+    readonly remote: string;
+    readonly token: string;
+    readonly sourceRevision: SourceRevision;
+}): SourceCapture;
+/** Capture one explicit committed revision without manufacturing a branch. */
+export declare function createLocalCommitSourceCapture(repositoryPath: string, sourceRevision: SourceRevision): SourceCapture;
+/** A first-party editable source tree ready to seed into an Artifacts template. */
+export type FirstPartyAppSourceDistribution = Readonly<{
+    readonly appId: AppId;
+    readonly sourceRevision: SourceRevision;
+    readonly sourceTreeDigest: ReturnType<typeof parseSha256Digest>;
+    readonly appDirectory: string;
+    readonly files: readonly Readonly<{
+        readonly path: string;
+        readonly contents: Uint8Array;
+    }>[];
+}>;
+/**
+ * Project one pinned first-party App and its pnpm workspace dependency graph
+ * without changing upstream files or manufacturing Git history. The caller
+ * records the returned provenance on the Artifacts template seed commit.
+ */
+export declare function createFirstPartyAppSourceDistribution(options: {
+    readonly appId: string;
+    readonly source: CapturedSource;
+    readonly entry: string;
+}): Effect.Effect<FirstPartyAppSourceDistribution, unknown>;
+/** How one build executor is composed; never part of a recipe or request. */
+export type LocalBuildExecutorOptions = Readonly<{
+    packageStoreDirectory?: string;
+    /**
+     * `run` executes a dependency's declared `fungi.build.script`. Only the
+     * admitted Computer build sets it; every other composition refuses a source
+     * that declares one, before installing anything.
+     */
+    packageScripts?: "run";
+    /** Hears how long the dependency install and the compile each took. */
+    onPhase?: (phase: "install" | "build", milliseconds: number) => void;
+}>;
+/** Exact pinned esbuild options shared by local builds and artifact-budget proofs. */
+export declare function localSnapshotBuildOptions(source: CapturedSource, recipe: PinnedRecipe, emission: DefinitionEmission): esbuild.BuildOptions;
+/** Local proving adapter; it builds only the captured extracted snapshot. */
+export declare function createLocalBuildExecutor(options?: LocalBuildExecutorOptions): BuildExecutor;
+/** Local proving adapter; the configured root is private and write-once. */
+export declare function createLocalArtifactWriter(artifactRoot: string, assetPolicy?: AssetBuildPolicy): ArtifactWriter;
+/** Local Git, recipe and artifact directory configuration with a Release catalog. */
+export type LocalAppPublisherOptions = Readonly<{
+    readonly config: unknown;
+    readonly releaseCatalog: ReleaseCreator;
+}>;
+/** Construct the complete local proving adapter around the provider-neutral core. */
+export declare function createLocalAppPublisher(options: LocalAppPublisherOptions): AppPublisher;