@fungi.computer/puffball 0.0.0-stage → 0.0.1

package/dist/index.d.ts

@@ -0,0 +1,31 @@
+import type { AppReleaseCatalog, AppReleaseCatalogOptions } from "./internal/app-release-contract.js";
+export * from "./internal/app-release-contract.js";
+export { appCapabilityIds, appHandlers, appRoles, appStorageScopes, emptyAppDeclaration, isEmptyAppDeclaration, } from "./app-vocabulary.js";
+export type { AppApi, AppBackendBinding, AppCapabilityId, AppDeclaration, AppDeclaredCommand, AppHandler, AppRole, AppStorageScope, AppStorageKey, } from "./app-vocabulary.js";
+/** Parse an opaque Global App identifier. */
+export declare const parseAppId: (input: unknown) => import("./internal/app-release-contract.js").AppId;
+/** Parse a Cairn-issued App transition identity. */
+export declare const parseAppTransitionId: (input: unknown) => import("./internal/app-release-contract.js").AppTransitionId;
+/** Parse an opaque immutable Release identifier. */
+export declare const parseReleaseId: (input: unknown) => import("./internal/app-release-contract.js").ReleaseId;
+/** Parse an opaque anonymous public-Surface identifier. */
+export declare const parsePublicSurfaceId: (input: unknown) => import("./internal/app-release-contract.js").PublicSurfaceId;
+/** Publisher issues customer Surface identities through Cairn, never from slugs. */
+export declare const issuePublicSurfaceId: () => import("./internal/app-release-contract.js").PublicSurfaceId;
+/** Parse an opaque bounded artifact reference. */
+export declare const parseArtifactRef: (input: unknown) => import("./internal/app-release-contract.js").ArtifactRef;
+/** Parse a caller-provided idempotency key. */
+export declare const parseIdempotencyKey: (input: unknown) => import("./internal/app-release-contract.js").IdempotencyKey;
+/** Parse a pinned lowercase Git source revision. */
+export declare const parseSourceRevision: (input: unknown) => import("./internal/app-release-contract.js").SourceRevision;
+/** Parse a lowercase SHA-256 digest. */
+export declare const parseSha256Digest: (input: unknown) => import("./internal/app-release-contract.js").Sha256Digest;
+/** Parse a canonical local origin-relative stable route. */
+export declare const parseStableRoute: (input: unknown) => import("./internal/app-release-contract.js").StableRoute;
+/**
+ * Create the App Release catalog.
+ *
+ * The default Promise facade adapts each foreign port once before calling the
+ * same Effect-native core.
+ */
+export declare function createAppReleaseCatalog(options: AppReleaseCatalogOptions): AppReleaseCatalog;

package/dist/index.js

@@ -0,0 +1,85 @@
+import * as Cause from "effect/Cause";
+import * as Effect from "effect/Effect";
+import * as Exit from "effect/Exit";
+import * as Option from "effect/Option";
+import { adaptPromiseAppReleaseStore, adaptPromiseArtifactReader, createAppReleaseCore, decodeAppId, decodeAppTransitionId, decodeArtifactRef, decodeIdempotencyKey, decodePublicSurfaceId, decodeReleaseId, decodeSha256Digest, decodeSourceRevision, decodeStableRoute, } from "./effect.js";
+import { AppReleaseInputError } from "./internal/app-release-contract.js";
+import { appSurfaceIdCodec } from "./internal/app-release-schema.js";
+export * from "./internal/app-release-contract.js";
+export { appCapabilityIds, appHandlers, appRoles, appStorageScopes, emptyAppDeclaration, isEmptyAppDeclaration, } from "./app-vocabulary.js";
+/**
+ * Adapt one canonical decoder to the fixed public parser error boundary.
+ *
+ * The Effect-facing decoder remains the grammar authority; this root only
+ * projects its success value or replaces every rejection with a fixed error.
+ */
+function makeParser(parserName, decode) {
+    return (input) => {
+        const decoded = decode(input);
+        if (decoded._tag === "Success")
+            return decoded.success;
+        throw new AppReleaseInputError(parserName);
+    };
+}
+/** Parse an opaque Global App identifier. */
+export const parseAppId = makeParser("AppId", decodeAppId);
+/** Parse a Cairn-issued App transition identity. */
+export const parseAppTransitionId = makeParser("AppTransitionId", decodeAppTransitionId);
+/** Parse an opaque immutable Release identifier. */
+export const parseReleaseId = makeParser("ReleaseId", decodeReleaseId);
+/** Parse an opaque anonymous public-Surface identifier. */
+export const parsePublicSurfaceId = makeParser("PublicSurfaceId", decodePublicSurfaceId);
+/** Publisher issues customer Surface identities through Cairn, never from slugs. */
+export const issuePublicSurfaceId = () => parsePublicSurfaceId(appSurfaceIdCodec.generate());
+/** Parse an opaque bounded artifact reference. */
+export const parseArtifactRef = makeParser("ArtifactRef", decodeArtifactRef);
+/** Parse a caller-provided idempotency key. */
+export const parseIdempotencyKey = makeParser("IdempotencyKey", decodeIdempotencyKey);
+/** Parse a pinned lowercase Git source revision. */
+export const parseSourceRevision = makeParser("SourceRevision", decodeSourceRevision);
+/** Parse a lowercase SHA-256 digest. */
+export const parseSha256Digest = makeParser("Sha256Digest", decodeSha256Digest);
+/** Parse a canonical local origin-relative stable route. */
+export const parseStableRoute = makeParser("StableRoute", decodeStableRoute);
+/**
+ * Create the App Release catalog.
+ *
+ * The default Promise facade adapts each foreign port once before calling the
+ * same Effect-native core.
+ */
+export function createAppReleaseCatalog(options) {
+    const store = adaptPromiseAppReleaseStore(options.store);
+    const artifactReader = adaptPromiseArtifactReader(options.artifactReader);
+    const core = options.artifactPolicy === undefined
+        ? createAppReleaseCore({ store, artifactReader })
+        : createAppReleaseCore({
+            store,
+            artifactReader,
+            artifactPolicy: options.artifactPolicy,
+        });
+    return {
+        createApp: (app) => runDefault(core.createApp(app)),
+        createRelease: (release) => runDefault(core.createRelease(release)),
+        verifyReleaseArtifact: (releaseId) => runDefault(core.verifyReleaseArtifact(releaseId)),
+        resolveEligibleReleaseArtifact: (releaseId) => runDefault(core.resolveEligibleReleaseArtifact(releaseId)),
+        resolveEligibleApp: (releaseId) => runDefault(core.resolveEligibleApp(releaseId)),
+        resolveEligibleAppMetadata: (releaseId) => runDefault(core.resolveEligibleAppMetadata(releaseId)),
+        resolvePublicSurfaceAuthority: (stableRoute) => runDefault(core.resolvePublicSurfaceAuthority(stableRoute)),
+        resolvePublicSurfaceAuthorityVersion: (stableRoute, releaseId) => runDefault(core.resolvePublicSurfaceAuthorityVersion(stableRoute, releaseId)),
+        createPublicSurface: (surface) => runDefault(core.createPublicSurface(surface)),
+        transition: (request) => runDefault(core.transition(request)),
+        resolvePublicAssetBuild: (stableRoute) => runDefault(core.resolvePublicAssetBuild(stableRoute)),
+        resolvePublicAssetBuildVersion: (stableRoute, releaseId) => runDefault(core.resolvePublicAssetBuildVersion(stableRoute, releaseId)),
+        resolvePublicWebsite: (stableRoute) => runDefault(core.resolvePublicWebsite(stableRoute)),
+        resolvePublicWebsiteVersion: (stableRoute, releaseId) => runDefault(core.resolvePublicWebsiteVersion(stableRoute, releaseId)),
+    };
+}
+function runDefault(program) {
+    return Effect.runPromiseExit(program).then((exit) => {
+        if (Exit.isSuccess(exit))
+            return exit.value;
+        const failure = Option.getOrUndefined(Cause.findErrorOption(exit.cause));
+        const error = failure ?? Cause.squash(exit.cause);
+        return Promise.reject(error instanceof Error ? error : new Error(String(error)));
+    });
+}

package/dist/internal/app-description.d.ts

@@ -0,0 +1,14 @@
+import * as Effect from "effect/Effect";
+import { type AppDescription } from "../app.js";
+import type { AppReleaseArtifactReader } from "./app-release-artifact-reader.js";
+import type { ArtifactVerificationIntent, VerifiedAppDescription } from "./app-release-contract.js";
+import { type ArtifactSnapshotPolicy, type VerifiedArtifactSnapshot, type VerifiedArtifactSnapshotFailure } from "./verified-artifact-snapshot.js";
+/** Resolve only the closed code children; ordinary use never loads the UI's asset tree. */
+export declare function readAppDescription(reader: AppReleaseArtifactReader, root: VerifiedArtifactSnapshot, policy: ArtifactSnapshotPolicy, verification?: ArtifactVerificationIntent): Effect.Effect<AppDescription, VerifiedArtifactSnapshotFailure>;
+/**
+ * Decode and normalize a verified App root for publication persistence.
+ */
+export declare function readVerifiedAppDescription(reader: AppReleaseArtifactReader, root: VerifiedArtifactSnapshot, policy: ArtifactSnapshotPolicy, verification?: ArtifactVerificationIntent): Effect.Effect<{
+    readonly description: AppDescription;
+    readonly metadata: VerifiedAppDescription;
+}, VerifiedArtifactSnapshotFailure>;

package/dist/internal/app-description.js

@@ -0,0 +1,98 @@
+import * as Effect from "effect/Effect";
+import * as Schema from "effect/Schema";
+import { appBuildJsonSchema, appMediaType, } from "../app.js";
+import { emptyAppDeclaration } from "../app-vocabulary.js";
+import { backendJsonSchema, backendMediaType } from "../backend.js";
+import { readVerifiedArtifactSnapshot, } from "./verified-artifact-snapshot.js";
+/** Resolve only the closed code children; ordinary use never loads the UI's asset tree. */
+export function readAppDescription(reader, root, policy, verification) {
+    return readVerifiedAppDescription(reader, root, policy, verification).pipe(Effect.map(({ description }) => description));
+}
+/**
+ * Decode and normalize a verified App root for publication persistence.
+ */
+export function readVerifiedAppDescription(reader, root, policy, verification) {
+    return Effect.gen(function* () {
+        if (root.mediaType !== appMediaType) {
+            return yield* Effect.fail(invalid());
+        }
+        const app = yield* Schema.decodeUnknownEffect(appBuildJsonSchema)(new TextDecoder().decode(root.bytes.copy()), { onExcessProperty: "error" }).pipe(Effect.mapError(invalid));
+        const ui = "ui" in app ? yield* readChild(app.ui) : null;
+        const backend = "backend" in app ? yield* readChild(app.backend) : null;
+        const description = yield* describe(ui, backend);
+        const metadataBackend = "backend" in app
+            ? yield* describeVerifiedBackend(app.backend, description.backend)
+            : null;
+        return {
+            description,
+            metadata: {
+                format: "fungi-app-v1",
+                ui: "ui" in app ? referenceFromBuild(app.ui) : null,
+                backend: metadataBackend,
+                declaration: app.declaration ?? emptyAppDeclaration,
+            },
+        };
+    });
+    function readChild(child) {
+        const expected = {
+            artifactRef: child.artifactRef,
+            expectedDigest: child.digest,
+            expectedObject: {
+                version: child.version,
+                byteLength: child.byteLength,
+            },
+        };
+        const input = verification === undefined ? expected : { ...expected, verification };
+        return readVerifiedArtifactSnapshot(reader, input, policy).pipe(Effect.flatMap((snapshot) => snapshot.mediaType === child.mediaType &&
+            snapshot.byteLength === child.byteLength
+            ? Effect.succeed(snapshot)
+            : Effect.fail(invalid())));
+    }
+}
+function describeVerifiedBackend(build, backend) {
+    if (backend === null)
+        return Effect.fail(invalid());
+    return Effect.succeed({
+        artifact: referenceFromBuild(build),
+        profile: profileFromDescriptor(backend),
+    });
+}
+function referenceFromBuild(child) {
+    return {
+        artifactRef: child.artifactRef,
+        digest: child.digest,
+        mediaType: child.mediaType,
+        version: child.version,
+        byteLength: child.byteLength,
+    };
+}
+function profileFromDescriptor(backend) {
+    const descriptor = backend.descriptor;
+    return {
+        runtime: descriptor.runtime,
+        compatibilityDate: descriptor.compatibilityDate,
+        exportName: descriptor.exportName,
+    };
+}
+function describe(root, backend) {
+    return Effect.gen(function* () {
+        const ui = root !== null &&
+            (root.mediaType === "text/html; charset=utf-8" ||
+                root.mediaType === "application/vnd.fungi.app-assets+json")
+            ? { ...root, mediaType: root.mediaType }
+            : null;
+        const code = root?.mediaType === backendMediaType ? root : backend;
+        const descriptor = code === null
+            ? null
+            : yield* Schema.decodeUnknownEffect(backendJsonSchema)(new TextDecoder().decode(code.bytes.copy()), { onExcessProperty: "error" }).pipe(Effect.mapError(invalid));
+        return {
+            ui,
+            backend: code !== null && descriptor !== null
+                ? { digest: code.digest, descriptor }
+                : null,
+        };
+    });
+}
+function invalid() {
+    return { kind: "invalid-snapshot" };
+}

package/dist/internal/app-release-artifact-reader.d.ts

@@ -0,0 +1,26 @@
+import * as Effect from "effect/Effect";
+import type { ArtifactRef, ArtifactVerificationIntent, Sha256Digest } from "./app-release-contract.js";
+/** Closed infrastructure failure at the hostile artifact-reader boundary. */
+export type AppReleaseArtifactReaderUnavailable = {
+    readonly kind: "unavailable";
+};
+/**
+ * Effect-native artifact reader port.
+ *
+ * A reader result is hostile until the App Release core decodes it through its
+ * canonical schema. This port owns the only direct unknown success value.
+ */
+export type AppReleaseArtifactReader = {
+    /** Resolve one stored artifact reference for its expected immutable digest. */
+    read(input: {
+        readonly artifactRef: ArtifactRef;
+        readonly expectedDigest: Sha256Digest;
+        /** Native version and size of a child named by a verified App root. */
+        readonly expectedObject?: {
+            readonly version: string;
+            readonly byteLength: number;
+        };
+        /** Publication additionally verifies every object named by an asset manifest. */
+        readonly verification?: ArtifactVerificationIntent;
+    }): Effect.Effect<unknown, AppReleaseArtifactReaderUnavailable>;
+};

package/dist/internal/app-release-artifact-reader.js

@@ -0,0 +1 @@
+import * as Effect from "effect/Effect";