@fungi.computer/puffball 0.0.0-stage → 0.0.1

package/dist/internal/deterministic-memory-app-release-store.js

@@ -0,0 +1,319 @@
+import * as Schema from "effect/Schema";
+import { isReservedPublicRoute, publicRouteKey, publicRoutePolicy, publicRouteConfigurationSchema, } from "../public-route-policy.js";
+import { registerPromisePublicWebsiteAuthorityReader } from "./public-website-authority.js";
+import { sameReleaseTransitionMaterial } from "./release-transition-material.js";
+function copyApp(app) {
+    return { appId: app.appId };
+}
+function copyRelease(release) {
+    return {
+        releaseId: release.releaseId,
+        appId: release.appId,
+        artifact: {
+            artifactRef: release.artifact.artifactRef,
+            artifactDigest: release.artifact.artifactDigest,
+            provenance: {
+                sourceRevision: release.artifact.provenance.sourceRevision,
+                sourceTreeDigest: release.artifact.provenance.sourceTreeDigest,
+                buildRecipeDigest: release.artifact.provenance.buildRecipeDigest,
+            },
+        },
+    };
+}
+function copyPublicSurface(surface) {
+    return {
+        publicSurfaceId: surface.publicSurfaceId,
+        appId: surface.appId,
+        stableRoute: surface.stableRoute,
+    };
+}
+function copyTransition(transition) {
+    return { ...transition };
+}
+function copyReceipt(receipt) {
+    return {
+        transition: copyTransition(receipt.transition),
+        transitionId: receipt.transitionId,
+    };
+}
+function copyVerifiedAppDescription(description) {
+    return structuredClone(description);
+}
+function transitionKey(transition) {
+    return `${transition.kind}:${transition.idempotencyKey}`;
+}
+function transitionLookup(stored, request) {
+    if (stored === undefined)
+        return { kind: "absent" };
+    if (!sameReleaseTransitionMaterial(request, stored.request))
+        return { kind: "conflict" };
+    return { kind: "found", receipt: copyReceipt(stored.receipt) };
+}
+function successful(value) {
+    return { kind: "success", value };
+}
+/**
+ * Compose an in-process deterministic store for the narrow App/Release port.
+ *
+ * Store methods mutate only the private collections below. Decisions remain in
+ * pure helpers, and every returned record is copied, so callers cannot mutate
+ * retained state after an atomic create-or-observe operation.
+ */
+export function createDeterministicMemoryAppReleaseStore(options = { routes: { platformRoutes: [], structuralRoutes: [] } }) {
+    const routes = Schema.decodeUnknownSync(publicRouteConfigurationSchema, {
+        onExcessProperty: "error",
+    })(options.routes);
+    const apps = new Map();
+    const releases = new Map();
+    const publicSurfaces = new Map();
+    const claims = new Map();
+    const eligibleSurface = (surface) => {
+        const key = publicRouteKey(surface.stableRoute);
+        const held = claims.get(key);
+        if (held && held.publicSurfaceId !== surface.publicSurfaceId)
+            return false;
+        if (surface.publisher.kind === "platform")
+            return routes.platformRoutes.some((route) => route.appId === surface.appId &&
+                route.stableRoute === surface.stableRoute);
+        const publisher = options.publishers?.find((value) => value.appId === surface.appId);
+        if (publisher?.teamId !== surface.publisher.teamId ||
+            publisher.source.provider !== "artifacts" ||
+            publisher.source.repository !== surface.appId ||
+            !publisher.templateSeed ||
+            publisher.templateSeed.appId === surface.appId)
+            return false;
+        if (held)
+            return true;
+        if ([...claims.values()].filter((value) => value.publisher.kind === "customer" &&
+            value.publisher.teamId === surface.publisher.teamId).length >= publicRoutePolicy.maxPublicRoutesPerTeam)
+            return false;
+        return (!isReservedPublicRoute(surface.stableRoute, routes.structuralRoutes) &&
+            !routes.platformRoutes.some((value) => publicRouteKey(value.stableRoute) === key));
+    };
+    const verifications = new Map();
+    const revokedReleases = new Set();
+    const selectedReleases = new Map();
+    const surfaceReleaseHistory = new Map();
+    const transitions = new Map();
+    const transitionIds = new Set();
+    const readMemoryReleaseLifecycle = (releaseId) => {
+        const release = releases.get(releaseId);
+        const verification = verifications.get(releaseId);
+        return release === undefined
+            ? { kind: "absent" }
+            : {
+                kind: "found",
+                release: copyRelease(release),
+                verification: verification === undefined
+                    ? { kind: "unverified" }
+                    : {
+                        kind: "verified",
+                        digest: verification.digest,
+                        mediaType: verification.mediaType,
+                        description: copyVerifiedAppDescription(verification.description),
+                    },
+                revocation: revokedReleases.has(releaseId)
+                    ? { kind: "revoked" }
+                    : { kind: "active" },
+            };
+    };
+    const readPublicWebsiteAuthority = (request) => {
+        const matches = [...claims.values()]
+            .filter((surface) => surface.stableRoute === request.stableRoute)
+            .slice(0, 2);
+        if (matches.length === 0)
+            return Promise.resolve(successful({ kind: "absent" }));
+        if (matches.length === 2)
+            return Promise.resolve(successful({ kind: "ambiguous" }));
+        const surface = matches[0];
+        if (surface === undefined) {
+            return Promise.resolve({
+                kind: "failure",
+                failure: { kind: "unavailable" },
+            });
+        }
+        const app = apps.get(surface.appId);
+        if (app === undefined)
+            return Promise.resolve({
+                kind: "failure",
+                failure: { kind: "unavailable" },
+            });
+        const currentReleaseId = selectedReleases.get(surface.publicSurfaceId);
+        const releaseId = request.expectedReleaseId ?? currentReleaseId;
+        const sequence = releaseId === undefined
+            ? undefined
+            : surfaceReleaseHistory.get(surface.publicSurfaceId)?.get(releaseId);
+        if (currentReleaseId === undefined ||
+            releaseId === undefined ||
+            sequence === undefined) {
+            return Promise.resolve(successful({
+                kind: "unselected",
+                app: copyApp(app),
+                surface: copyPublicSurface(surface),
+            }));
+        }
+        const lifecycle = readMemoryReleaseLifecycle(releaseId);
+        return Promise.resolve(successful({
+            kind: "selected",
+            app: copyApp(app),
+            surface: copyPublicSurface(surface),
+            releaseId,
+            currentReleaseId,
+            sequence,
+            release: lifecycle,
+        }));
+    };
+    const store = {
+        readApp(appId) {
+            const app = apps.get(appId);
+            return Promise.resolve(successful(app === undefined
+                ? { kind: "absent" }
+                : { kind: "found", app: copyApp(app) }));
+        },
+        createAppIfAbsent(app) {
+            const existing = apps.get(app.appId);
+            if (existing !== undefined) {
+                return Promise.resolve(successful({ kind: "existing", app: copyApp(existing) }));
+            }
+            const created = copyApp(app);
+            apps.set(created.appId, created);
+            return Promise.resolve(successful({ kind: "created", app: copyApp(created) }));
+        },
+        readRelease(releaseId) {
+            const release = releases.get(releaseId);
+            return Promise.resolve(successful(release === undefined
+                ? { kind: "absent" }
+                : { kind: "found", release: copyRelease(release) }));
+        },
+        createReleaseIfAbsent(release) {
+            const existing = releases.get(release.releaseId);
+            if (existing !== undefined) {
+                return Promise.resolve(successful({ kind: "existing", release: copyRelease(existing) }));
+            }
+            const created = copyRelease(release);
+            releases.set(created.releaseId, created);
+            return Promise.resolve(successful({ kind: "created", release: copyRelease(created) }));
+        },
+        readPublicSurface(publicSurfaceId) {
+            const surface = publicSurfaces.get(publicSurfaceId);
+            return Promise.resolve(successful(surface === undefined
+                ? { kind: "absent" }
+                : { kind: "found", surface: copyPublicSurface(surface) }));
+        },
+        createPublicSurfaceIfAbsent(surface) {
+            const existing = [...publicSurfaces.values()].find((value) => value.publisher.teamId === surface.publisher.teamId &&
+                value.publisher.requestKey === surface.publisher.requestKey);
+            if (existing !== undefined) {
+                if (existing.appId !== surface.appId ||
+                    existing.stableRoute !== surface.stableRoute ||
+                    existing.publisher.kind !== surface.publisher.kind ||
+                    existing.publisher.userId !== surface.publisher.userId)
+                    return Promise.resolve(successful({ kind: "conflict" }));
+                return Promise.resolve(successful({
+                    kind: "existing",
+                    surface: copyPublicSurface(existing),
+                }));
+            }
+            if (publicSurfaces.has(surface.publicSurfaceId) ||
+                !eligibleSurface(surface) ||
+                [...publicSurfaces.values()].filter((value) => value.appId === surface.appId &&
+                    !surfaceReleaseHistory.has(value.publicSurfaceId)).length >= publicRoutePolicy.maxUnusedSurfacesPerApp)
+                return Promise.resolve(successful({ kind: "conflict" }));
+            const created = {
+                ...copyPublicSurface(surface),
+                publisher: { ...surface.publisher },
+            };
+            publicSurfaces.set(created.publicSurfaceId, created);
+            return Promise.resolve(successful({ kind: "created", surface: copyPublicSurface(created) }));
+        },
+        readReleaseLifecycle(releaseId) {
+            return Promise.resolve(successful(readMemoryReleaseLifecycle(releaseId)));
+        },
+        recordReleaseVerification(input) {
+            if (!releases.has(input.releaseId)) {
+                return Promise.resolve({
+                    kind: "failure",
+                    failure: { kind: "unavailable" },
+                });
+            }
+            const existing = verifications.get(input.releaseId);
+            if (existing === undefined) {
+                verifications.set(input.releaseId, {
+                    digest: input.digest,
+                    mediaType: input.mediaType,
+                    description: copyVerifiedAppDescription(input.description),
+                });
+            }
+            else if (existing.digest !== input.digest ||
+                JSON.stringify(existing.description) !==
+                    JSON.stringify(input.description)) {
+                return Promise.resolve({
+                    kind: "failure",
+                    failure: { kind: "unavailable" },
+                });
+            }
+            return Promise.resolve(successful({ kind: "recorded" }));
+        },
+        readTransition(request) {
+            const stored = transitions.get(transitionKey(request));
+            return Promise.resolve(successful(transitionLookup(stored, request)));
+        },
+        persistTransition(request, receipt) {
+            const key = transitionKey(request);
+            const stored = transitions.get(key);
+            if (stored !== undefined) {
+                const persistence = sameReleaseTransitionMaterial(request, stored.request)
+                    ? { kind: "existing", receipt: copyReceipt(stored.receipt) }
+                    : { kind: "conflict" };
+                return Promise.resolve(successful(persistence));
+            }
+            if (request.kind !== "revocation" &&
+                revokedReleases.has(request.releaseId)) {
+                return Promise.resolve(successful({ kind: "lifecycle-conflict" }));
+            }
+            if (transitionIds.has(receipt.transitionId)) {
+                return Promise.resolve(successful({ kind: "identity-collision" }));
+            }
+            if (request.kind !== "revocation") {
+                const surface = publicSurfaces.get(request.publicSurfaceId);
+                const release = releases.get(request.releaseId);
+                const verified = verifications.get(request.releaseId);
+                if (!surface ||
+                    surface.appId !== release?.appId ||
+                    verified?.digest !== release.artifact.artifactDigest ||
+                    !eligibleSurface(surface) ||
+                    (request.kind === "rollback" &&
+                        !surfaceReleaseHistory
+                            .get(request.publicSurfaceId)
+                            ?.has(request.releaseId)))
+                    return Promise.resolve(successful({ kind: "lifecycle-conflict" }));
+                claims.set(publicRouteKey(surface.stableRoute), surface);
+            }
+            const savedRequest = copyTransition(request);
+            const savedReceipt = copyReceipt(receipt);
+            transitions.set(key, { request: savedRequest, receipt: savedReceipt });
+            transitionIds.add(savedReceipt.transitionId);
+            if (request.kind === "revocation") {
+                revokedReleases.add(request.releaseId);
+            }
+            else {
+                selectedReleases.set(request.publicSurfaceId, request.releaseId);
+                const history = new Map(surfaceReleaseHistory.get(request.publicSurfaceId));
+                history.set(request.releaseId, transitions.size);
+                surfaceReleaseHistory.set(request.publicSurfaceId, history);
+            }
+            return Promise.resolve(successful({ kind: "created", receipt: copyReceipt(savedReceipt) }));
+        },
+    };
+    registerPromisePublicWebsiteAuthorityReader(store, async (requests) => {
+        const results = await Promise.all(requests.map(readPublicWebsiteAuthority));
+        const values = [];
+        for (const result of results) {
+            if (result.kind === "failure")
+                return result;
+            values.push(result.value);
+        }
+        return successful(values);
+    });
+    return store;
+}

package/dist/internal/failure.d.ts

@@ -0,0 +1,2 @@
+/** Report a failed operation without exposing artifact or request contents. */
+export declare function reportFailure(operation: string, cause: unknown): void;

package/dist/internal/failure.js

@@ -0,0 +1,9 @@
+import * as Redacted from "effect/Redacted";
+/** Report a failed operation without exposing artifact or request contents. */
+export function reportFailure(operation, cause) {
+    console.error(JSON.stringify({
+        event: "app_release_operation_failed",
+        operation,
+        causeKind: cause instanceof Error ? "error" : "non_error",
+    }), Redacted.make(cause));
+}

package/dist/internal/immutable-release-material.d.ts

@@ -0,0 +1,3 @@
+import type { Release } from "./app-release-contract.js";
+/** Compare every write-once fact carried by an immutable Release. */
+export declare function sameImmutableReleaseMaterial(left: Release, right: Release): boolean;

package/dist/internal/immutable-release-material.js

@@ -0,0 +1,13 @@
+/** Compare every write-once fact carried by an immutable Release. */
+export function sameImmutableReleaseMaterial(left, right) {
+    return (left.releaseId === right.releaseId &&
+        left.appId === right.appId &&
+        left.artifact.artifactRef === right.artifact.artifactRef &&
+        left.artifact.artifactDigest === right.artifact.artifactDigest &&
+        left.artifact.provenance.sourceRevision ===
+            right.artifact.provenance.sourceRevision &&
+        left.artifact.provenance.sourceTreeDigest ===
+            right.artifact.provenance.sourceTreeDigest &&
+        left.artifact.provenance.buildRecipeDigest ===
+            right.artifact.provenance.buildRecipeDigest);
+}

package/dist/internal/promise-app-release-store-adapter.d.ts

@@ -0,0 +1,9 @@
+import type { PromiseAppReleaseStore } from "./app-release-contract.js";
+import type { AppReleaseStore } from "./app-release-store.js";
+/**
+ * Adapt the Promise store projection at the one outer edge.
+ *
+ * Rejected Promise work is deliberately collapsed into the closed unavailable
+ * store outcome; infrastructure detail never crosses into catalog policy.
+ */
+export declare function adaptPromiseAppReleaseStore(projection: PromiseAppReleaseStore): AppReleaseStore;

package/dist/internal/promise-app-release-store-adapter.js

@@ -0,0 +1,65 @@
+import * as Effect from "effect/Effect";
+import * as Result from "effect/Result";
+import { decodePublicWebsiteAuthorityStoreResult, getPromisePublicWebsiteAuthorityReader, registerEffectPublicWebsiteAuthorityReader, } from "./public-website-authority.js";
+import { decodeAppCreateStoreResult, decodeAppReadStoreResult, decodePublicSurfaceCreateStoreResult, decodePublicSurfaceReadStoreResult, decodeReleaseLifecycleStoreResult, decodeReleaseVerificationRecordStoreResult, decodeReleaseCreateStoreResult, decodeReleaseReadStoreResult, decodeTransitionLookupStoreResult, decodeTransitionPersistenceStoreResult, } from "./app-release-schema.js";
+/**
+ * Adapt the Promise store projection at the one outer edge.
+ *
+ * Rejected Promise work is deliberately collapsed into the closed unavailable
+ * store outcome; infrastructure detail never crosses into catalog policy.
+ */
+export function adaptPromiseAppReleaseStore(projection) {
+    const store = {
+        readApp: (appId) => fromPromise(() => projection.readApp(appId), decodeAppReadStoreResult),
+        createAppIfAbsent: (app) => fromPromise(() => projection.createAppIfAbsent(app), decodeAppCreateStoreResult),
+        readRelease: (releaseId) => fromPromise(() => projection.readRelease(releaseId), decodeReleaseReadStoreResult),
+        createReleaseIfAbsent: (release) => fromPromise(() => projection.createReleaseIfAbsent(release), decodeReleaseCreateStoreResult),
+        readPublicSurface: (publicSurfaceId) => fromPromise(() => projection.readPublicSurface(publicSurfaceId), decodePublicSurfaceReadStoreResult),
+        createPublicSurfaceIfAbsent: (surface) => fromPromise(() => projection.createPublicSurfaceIfAbsent(surface), decodePublicSurfaceCreateStoreResult),
+        readReleaseLifecycle: (releaseId) => fromOptionalPromise(projection.readReleaseLifecycle === undefined
+            ? undefined
+            : () => projection.readReleaseLifecycle?.(releaseId), decodeReleaseLifecycleStoreResult),
+        recordReleaseVerification: (input) => fromOptionalPromise(projection.recordReleaseVerification === undefined
+            ? undefined
+            : () => projection.recordReleaseVerification?.(input), decodeReleaseVerificationRecordStoreResult),
+        readTransition: (request) => fromOptionalPromise(projection.readTransition === undefined
+            ? undefined
+            : () => projection.readTransition?.(request), decodeTransitionLookupStoreResult),
+        persistTransition: (request, receipt) => fromOptionalPromise(projection.persistTransition === undefined
+            ? undefined
+            : () => projection.persistTransition?.(request, receipt), decodeTransitionPersistenceStoreResult),
+    };
+    const websiteReader = getPromisePublicWebsiteAuthorityReader(projection);
+    if (websiteReader !== undefined)
+        registerEffectPublicWebsiteAuthorityReader(store, (request) => fromPromise(() => websiteReader(request), decodePublicWebsiteAuthorityStoreResult));
+    return store;
+}
+function fromOptionalPromise(operation, decodeResult) {
+    return operation === undefined
+        ? Effect.fail(unavailable())
+        : fromPromise(() => operation() ??
+            Promise.reject(new Error("App Release store operation unavailable")), decodeResult);
+}
+function fromPromise(operation, decodeResult) {
+    return Effect.tryPromise({
+        try: operation,
+        catch: unavailable,
+    }).pipe(Effect.flatMap((result) => Effect.try({
+        try: () => decodeResult(result),
+        catch: invalidStoreResult,
+    }).pipe(Effect.flatMap(storeOutcome))));
+}
+function storeOutcome(decoded) {
+    return Result.match(decoded, {
+        onFailure: () => Effect.fail(invalidStoreResult()),
+        onSuccess: (result) => result.kind === "success"
+            ? Effect.succeed(result.value)
+            : Effect.fail(result.failure),
+    });
+}
+function unavailable() {
+    return { kind: "unavailable" };
+}
+function invalidStoreResult() {
+    return { kind: "invalid-store-result" };
+}

package/dist/internal/promise-artifact-reader-adapter.d.ts

@@ -0,0 +1,9 @@
+import type { ArtifactReader } from "./app-release-contract.js";
+import type { AppReleaseArtifactReader } from "./app-release-artifact-reader.js";
+/**
+ * Adapt the Promise artifact-reader projection at the one outer edge.
+ *
+ * Successful values remain hostile until the core's canonical schema decodes
+ * them. A rejected Promise is closed to the reader's unavailable failure.
+ */
+export declare function adaptPromiseArtifactReader(projection: ArtifactReader): AppReleaseArtifactReader;

package/dist/internal/promise-artifact-reader-adapter.js

@@ -0,0 +1,18 @@
+import * as Effect from "effect/Effect";
+/**
+ * Adapt the Promise artifact-reader projection at the one outer edge.
+ *
+ * Successful values remain hostile until the core's canonical schema decodes
+ * them. A rejected Promise is closed to the reader's unavailable failure.
+ */
+export function adaptPromiseArtifactReader(projection) {
+    return {
+        read: (input) => Effect.tryPromise({
+            try: () => projection.read(input),
+            catch: unavailable,
+        }),
+    };
+}
+function unavailable() {
+    return { kind: "unavailable" };
+}

package/dist/internal/public-route-sql.d.ts

@@ -0,0 +1,10 @@
+/** Only trusted column expressions enter DDL; all request values are bound. */
+export declare function routeKeySql(column: string): string;
+/** Immutable Surface metadata and database-enforced policy comparison key. */
+export declare const publicSurfaceTableSql: string;
+/** One write: pre-check custody and bound unused rows before minting any Surface. */
+export declare const insertPublicSurfaceSql = "\nWITH candidate(public_surface_id,app_id,stable_route,route_key,\n               publisher_team_id,publisher_user_id,authority_kind,request_key)\nAS (VALUES (?,?,?,?,?,?,?,?))\nINSERT INTO app_release_public_surfaces\n  (public_surface_id,app_id,stable_route,route_key,publisher_team_id,publisher_user_id,authority_kind,request_key)\nSELECT s.public_surface_id,s.app_id,s.stable_route,s.route_key,\n       s.publisher_team_id,s.publisher_user_id,s.authority_kind,s.request_key\nFROM candidate s\nJOIN app_release_route_policy policy ON policy.singleton=1\nLEFT JOIN app_release_route_claims c ON c.route_key=s.route_key\nWHERE \nNOT EXISTS (SELECT 1 FROM app_release_safety_takedowns a\n  WHERE a.app_id=s.app_id AND a.stable_route=s.stable_route)\nAND\nNOT EXISTS (\n  SELECT 1 FROM app_release_surface_retirements x\n  WHERE x.public_surface_id=s.public_surface_id\n)\nAND NOT EXISTS (\n  SELECT 1 FROM app_release_team_route_blocks b\n  WHERE b.team_id=s.publisher_team_id AND b.route_key=s.route_key\n)\nAND (c.route_key IS NOT NULL OR NOT EXISTS (\n  SELECT 1 FROM app_release_route_holds h\n  WHERE h.route_key=s.route_key AND h.until_s>unixepoch()\n))\nAND (c.route_key IS NULL OR\n     (c.public_surface_id=s.public_surface_id AND c.state='held'))\nAND (s.authority_kind='platform' OR c.public_surface_id=s.public_surface_id OR\n     (SELECT count(*) FROM app_release_route_claims own\n      JOIN app_release_public_surfaces owned_surface ON owned_surface.public_surface_id=own.public_surface_id\n      WHERE own.team_id=s.publisher_team_id AND owned_surface.authority_kind='customer')<policy.max_team_routes)\nAND (\n  (s.authority_kind='platform' AND EXISTS (\n    SELECT 1 FROM app_release_platform_routes p\n    WHERE p.stable_route=s.stable_route AND p.app_id=s.app_id\n  ))\n  OR\n  (s.authority_kind='customer' AND EXISTS (\n    SELECT 1 FROM app_release_team_publishers p\n    WHERE p.app_id=s.app_id AND p.team_id=s.publisher_team_id\n      AND p.source_provider='artifacts' AND p.source_repository=p.app_id\n      AND p.source_branch='main' AND p.template_app_id IS NOT NULL\n      AND p.template_app_id<>p.app_id AND p.template_seed_revision IS NOT NULL\n  ) AND (\n    c.public_surface_id=s.public_surface_id OR (\n      NOT EXISTS (SELECT 1 FROM app_release_platform_routes p\n                  WHERE p.route_key=s.route_key)\n      AND NOT EXISTS (\n        SELECT 1 FROM app_release_reserved_route_keys k\n        WHERE (k.match_kind='exact' AND k.route_key=s.route_key)\n           OR (k.match_kind='prefix' AND\n               substr(s.route_key,1,length(k.route_key))=k.route_key\n               AND NOT EXISTS (SELECT 1 FROM app_release_route_brand_exceptions x WHERE x.route_key=s.route_key))\n      )\n    )\n  ))\n)\nAND (SELECT count(*) FROM app_release_public_surfaces unused\n     WHERE unused.app_id=s.app_id AND NOT EXISTS (\n       SELECT 1 FROM app_release_transitions t\n       WHERE t.public_surface_id=unused.public_surface_id\n         AND t.operation_kind IN ('promotion','rollback')\n     ))<policy.max_unused_surfaces_per_app\nON CONFLICT DO NOTHING\nRETURNING *";
+/** Current route custody is separate from immutable Surface and transition history. */
+export declare const publicRouteSchemaSql: string;
+/** Operator replay history preserves original Surface attribution. */
+export declare const platformOwnerReplaySchemaSql = "\nCREATE TABLE app_release_platform_owner_replays (sequence INTEGER PRIMARY KEY AUTOINCREMENT, public_surface_id TEXT NOT NULL, app_id TEXT NOT NULL, stable_route TEXT NOT NULL, owner_team_id TEXT NOT NULL, publisher_user_id TEXT NOT NULL, operator_user_id TEXT NOT NULL, recorded_at INTEGER NOT NULL) STRICT;\nCREATE INDEX app_release_platform_owner_replays_app ON app_release_platform_owner_replays(app_id);\n";