@fabrika/provider-zerops 0.9.0-dev.1 → 0.9.0-dev.2

package/types/src/namespace/codec.d.ts

@@ -0,0 +1,334 @@
+import type { ProviderCodec, ProviderDeploymentNamespace, ProviderEnvelope, ProviderNamespaceMutationInput } from '@fabrika/provider-contract';
+import { z } from 'zod';
+import type { NormalizedZeropsNamespaceTarget, ZeropsNamespaceOptions, ZeropsNamespaceTarget } from './types';
+/** The one value an update may give `proxySource`: re-pin the namespace's proxy to the installation's default. */
+export declare const ZEROPS_PROXY_SOURCE_CURRENT = "current";
+export declare const postgresSchema: z.ZodEffects<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+    type: z.ZodLiteral<"postgresql:ha@18">;
+    profile: z.ZodOptional<z.ZodEnum<["oltp-staging", "oltp-production", "oltp-enterprise", "olap-production", "writeheavy-production"]>>;
+}, "strip", z.ZodTypeAny, {
+    type: "postgresql:ha@18";
+    profile?: "oltp-staging" | "oltp-production" | "oltp-enterprise" | "olap-production" | "writeheavy-production" | undefined;
+}, {
+    type: "postgresql:ha@18";
+    profile?: "oltp-staging" | "oltp-production" | "oltp-enterprise" | "olap-production" | "writeheavy-production" | undefined;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"postgresql:single@18">;
+    profile: z.ZodOptional<z.ZodEnum<["oltp-hobby", "oltp-staging", "oltp-production", "olap-production", "writeheavy-production"]>>;
+}, "strip", z.ZodTypeAny, {
+    type: "postgresql:single@18";
+    profile?: "oltp-staging" | "oltp-production" | "olap-production" | "writeheavy-production" | "oltp-hobby" | undefined;
+}, {
+    type: "postgresql:single@18";
+    profile?: "oltp-staging" | "oltp-production" | "olap-production" | "writeheavy-production" | "oltp-hobby" | undefined;
+}>]>, {
+    type: "postgresql:ha@18";
+    profile?: "oltp-staging" | "oltp-production" | "oltp-enterprise" | "olap-production" | "writeheavy-production" | undefined;
+} | {
+    type: "postgresql:single@18";
+    profile?: "oltp-staging" | "oltp-production" | "olap-production" | "writeheavy-production" | "oltp-hobby" | undefined;
+}, {
+    type: "postgresql:ha@18";
+    profile?: "oltp-staging" | "oltp-production" | "oltp-enterprise" | "olap-production" | "writeheavy-production" | undefined;
+} | {
+    type: "postgresql:single@18";
+    profile?: "oltp-staging" | "oltp-production" | "olap-production" | "writeheavy-production" | "oltp-hobby" | undefined;
+}>;
+/**
+ * What an update request's payload may name: any target field, each optional, and no field the target
+ * does not have — at the top level or inside `postgres`. The target schema STRIPS an unknown key, which
+ * would turn a misspelt field into a silent no-op. `proxySource` also takes `current`, the installation's
+ * default pin; the plan refuses any other pin than that one (ADR-0045).
+ */
+export declare const namespaceUpdatePayloadSchema: z.ZodObject<{
+    proxyDeployment: z.ZodOptional<z.ZodOptional<z.ZodEffects<z.ZodObject<{
+        manifestSha256: z.ZodOptional<z.ZodString>;
+        appVersionId: z.ZodString;
+        repository: z.ZodObject<{
+            owner: z.ZodString;
+            name: z.ZodEffects<z.ZodString, string, string>;
+        }, "strict", z.ZodTypeAny, {
+            name: string;
+            owner: string;
+        }, {
+            name: string;
+            owner: string;
+        }>;
+        commitSha: z.ZodString;
+        descriptorSha256: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        commitSha: string;
+        appVersionId: string;
+        repository: {
+            name: string;
+            owner: string;
+        };
+        descriptorSha256: string;
+        manifestSha256?: string | undefined;
+    }, {
+        commitSha: string;
+        appVersionId: string;
+        repository: {
+            name: string;
+            owner: string;
+        };
+        descriptorSha256: string;
+        manifestSha256?: string | undefined;
+    }>, {
+        commitSha: string;
+        appVersionId: string;
+        repository: {
+            name: string;
+            owner: string;
+        };
+        descriptorSha256: string;
+        manifestSha256?: string | undefined;
+    }, {
+        commitSha: string;
+        appVersionId: string;
+        repository: {
+            name: string;
+            owner: string;
+        };
+        descriptorSha256: string;
+        manifestSha256?: string | undefined;
+    }>>>;
+    proxyBuild: z.ZodOptional<z.ZodOptional<z.ZodEffects<z.ZodObject<{
+        appVersionId: z.ZodString;
+        triggered: z.ZodBoolean;
+        manifestSha256: z.ZodOptional<z.ZodString>;
+    }, "strict", z.ZodTypeAny, {
+        appVersionId: string;
+        triggered: boolean;
+        manifestSha256?: string | undefined;
+    }, {
+        appVersionId: string;
+        triggered: boolean;
+        manifestSha256?: string | undefined;
+    }>, {
+        appVersionId: string;
+        triggered: boolean;
+        manifestSha256?: string | undefined;
+    }, {
+        appVersionId: string;
+        triggered: boolean;
+        manifestSha256?: string | undefined;
+    }>>>;
+    projectName: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+    corePackage: z.ZodOptional<z.ZodOptional<z.ZodEnum<["LIGHT", "SERIOUS"]>>>;
+    publicAccess: z.ZodOptional<z.ZodOptional<z.ZodEnum<["custom-domain", "zerops-subdomain"]>>>;
+    managed: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
+    projectId: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+    proxyServiceId: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+    postgresServiceId: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+    proxyConfigured: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
+    proxyBaselineSequence: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+    proxyAppVersionId: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+    proxyHosts: z.ZodOptional<z.ZodOptional<z.ZodArray<z.ZodObject<{
+        host: z.ZodString;
+        port: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        port: number;
+        host: string;
+    }, {
+        port: number;
+        host: string;
+    }>, "many">>>;
+    ready: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
+} & {
+    postgres: z.ZodOptional<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+        type: z.ZodLiteral<"postgresql:ha@18">;
+        profile: z.ZodOptional<z.ZodEnum<["oltp-staging", "oltp-production", "oltp-enterprise", "olap-production", "writeheavy-production"]>>;
+    }, "strict", z.ZodTypeAny, {
+        type: "postgresql:ha@18";
+        profile?: "oltp-staging" | "oltp-production" | "oltp-enterprise" | "olap-production" | "writeheavy-production" | undefined;
+    }, {
+        type: "postgresql:ha@18";
+        profile?: "oltp-staging" | "oltp-production" | "oltp-enterprise" | "olap-production" | "writeheavy-production" | undefined;
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"postgresql:single@18">;
+        profile: z.ZodOptional<z.ZodEnum<["oltp-hobby", "oltp-staging", "oltp-production", "olap-production", "writeheavy-production"]>>;
+    }, "strict", z.ZodTypeAny, {
+        type: "postgresql:single@18";
+        profile?: "oltp-staging" | "oltp-production" | "olap-production" | "writeheavy-production" | "oltp-hobby" | undefined;
+    }, {
+        type: "postgresql:single@18";
+        profile?: "oltp-staging" | "oltp-production" | "olap-production" | "writeheavy-production" | "oltp-hobby" | undefined;
+    }>]>>;
+    proxySource: z.ZodOptional<z.ZodUnion<[z.ZodLiteral<"current">, z.ZodEffects<z.ZodObject<{
+        repository: z.ZodObject<{
+            owner: z.ZodString;
+            name: z.ZodEffects<z.ZodString, string, string>;
+        }, "strict", z.ZodTypeAny, {
+            name: string;
+            owner: string;
+        }, {
+            name: string;
+            owner: string;
+        }>;
+        commitSha: z.ZodString;
+        descriptor: z.ZodObject<{
+            path: z.ZodLiteral<"zerops.yaml">;
+            contents: z.ZodEffects<z.ZodString, string, string>;
+            sha256: z.ZodString;
+        }, "strict", z.ZodTypeAny, {
+            sha256: string;
+            path: "zerops.yaml";
+            contents: string;
+        }, {
+            sha256: string;
+            path: "zerops.yaml";
+            contents: string;
+        }>;
+    }, "strict", z.ZodTypeAny, {
+        commitSha: string;
+        repository: {
+            name: string;
+            owner: string;
+        };
+        descriptor: {
+            sha256: string;
+            path: "zerops.yaml";
+            contents: string;
+        };
+    }, {
+        commitSha: string;
+        repository: {
+            name: string;
+            owner: string;
+        };
+        descriptor: {
+            sha256: string;
+            path: "zerops.yaml";
+            contents: string;
+        };
+    }>, {
+        commitSha: string;
+        repository: {
+            name: string;
+            owner: string;
+        };
+        descriptor: {
+            sha256: string;
+            path: "zerops.yaml";
+            contents: string;
+        };
+    }, {
+        commitSha: string;
+        repository: {
+            name: string;
+            owner: string;
+        };
+        descriptor: {
+            sha256: string;
+            path: "zerops.yaml";
+            contents: string;
+        };
+    }>]>>;
+}, "strict", z.ZodTypeAny, {
+    corePackage?: "LIGHT" | "SERIOUS" | undefined;
+    postgres?: {
+        type: "postgresql:ha@18";
+        profile?: "oltp-staging" | "oltp-production" | "oltp-enterprise" | "olap-production" | "writeheavy-production" | undefined;
+    } | {
+        type: "postgresql:single@18";
+        profile?: "oltp-staging" | "oltp-production" | "olap-production" | "writeheavy-production" | "oltp-hobby" | undefined;
+    } | undefined;
+    projectId?: string | undefined;
+    projectName?: string | undefined;
+    proxySource?: {
+        commitSha: string;
+        repository: {
+            name: string;
+            owner: string;
+        };
+        descriptor: {
+            sha256: string;
+            path: "zerops.yaml";
+            contents: string;
+        };
+    } | "current" | undefined;
+    proxyBuild?: {
+        appVersionId: string;
+        triggered: boolean;
+        manifestSha256?: string | undefined;
+    } | undefined;
+    proxyDeployment?: {
+        commitSha: string;
+        appVersionId: string;
+        repository: {
+            name: string;
+            owner: string;
+        };
+        descriptorSha256: string;
+        manifestSha256?: string | undefined;
+    } | undefined;
+    publicAccess?: "custom-domain" | "zerops-subdomain" | undefined;
+    managed?: boolean | undefined;
+    proxyServiceId?: string | undefined;
+    postgresServiceId?: string | undefined;
+    proxyConfigured?: boolean | undefined;
+    proxyBaselineSequence?: number | undefined;
+    proxyAppVersionId?: string | undefined;
+    proxyHosts?: {
+        port: number;
+        host: string;
+    }[] | undefined;
+    ready?: boolean | undefined;
+}, {
+    corePackage?: "LIGHT" | "SERIOUS" | undefined;
+    postgres?: {
+        type: "postgresql:ha@18";
+        profile?: "oltp-staging" | "oltp-production" | "oltp-enterprise" | "olap-production" | "writeheavy-production" | undefined;
+    } | {
+        type: "postgresql:single@18";
+        profile?: "oltp-staging" | "oltp-production" | "olap-production" | "writeheavy-production" | "oltp-hobby" | undefined;
+    } | undefined;
+    projectId?: string | undefined;
+    projectName?: string | undefined;
+    proxySource?: {
+        commitSha: string;
+        repository: {
+            name: string;
+            owner: string;
+        };
+        descriptor: {
+            sha256: string;
+            path: "zerops.yaml";
+            contents: string;
+        };
+    } | "current" | undefined;
+    proxyBuild?: {
+        appVersionId: string;
+        triggered: boolean;
+        manifestSha256?: string | undefined;
+    } | undefined;
+    proxyDeployment?: {
+        commitSha: string;
+        appVersionId: string;
+        repository: {
+            name: string;
+            owner: string;
+        };
+        descriptorSha256: string;
+        manifestSha256?: string | undefined;
+    } | undefined;
+    publicAccess?: "custom-domain" | "zerops-subdomain" | undefined;
+    managed?: boolean | undefined;
+    proxyServiceId?: string | undefined;
+    postgresServiceId?: string | undefined;
+    proxyConfigured?: boolean | undefined;
+    proxyBaselineSequence?: number | undefined;
+    proxyAppVersionId?: string | undefined;
+    proxyHosts?: {
+        port: number;
+        host: string;
+    }[] | undefined;
+    ready?: boolean | undefined;
+}>;
+export declare const zeropsNamespaceTargetCodec: ProviderCodec<ZeropsNamespaceTarget>;
+export declare const envelope: (target: ZeropsNamespaceTarget) => ProviderEnvelope;
+export declare const decodeEnvelope: (value: ProviderEnvelope) => ZeropsNamespaceTarget;
+export declare const normalizeTarget: (namespace: ProviderDeploymentNamespace, options: ZeropsNamespaceOptions) => NormalizedZeropsNamespaceTarget;
+export declare const normalizedNamespace: (namespace: ProviderDeploymentNamespace, options: ZeropsNamespaceOptions) => ProviderDeploymentNamespace;
+export declare const checkpoint: (input: ProviderNamespaceMutationInput, namespace: ProviderDeploymentNamespace, target: ZeropsNamespaceTarget) => Promise<ProviderDeploymentNamespace>;

package/types/src/namespace/constants.d.ts

@@ -0,0 +1,25 @@
+export declare const ZEROPS_NAMESPACE_PROXY_HOSTNAME = "proxy";
+export declare const ZEROPS_NAMESPACE_POSTGRES_HOSTNAME = "postgres";
+export declare const ZEROPS_NAMESPACE_IAM_ISSUER_VARIABLE = "FABRIKA_IAM_ISSUER";
+export declare const ZEROPS_NAMESPACE_IAM_KEY_VARIABLE = "FABRIKA_IAM_KEY";
+/** The platform-owned variable naming one URL per published HTTP port. READ_ONLY, written by Zerops. */
+export declare const ZEROPS_NAMESPACE_SUBDOMAIN_VARIABLE = "zeropsSubdomain";
+/**
+ * How an app reaches the namespace-owned PostgreSQL service as its own user `db` — port, database and TLS mode NAMED,
+ * not defaulted. Every part settled against a live account, none of it safe to infer:
+ *
+ *   • `${x_connectionString}` is `postgresql://${user}:${password}@${hostname}:${port}` — no database path. With
+ *     none, the libpq/postgres.js convention falls back to the USER name.
+ *   • `dbName` and `user` are both literally `db` on EVERY PostgreSQL service, whatever its hostname (checked on a
+ *     service named `wu2db`). `/${x_dbName}` says it out loud rather than relying on that fallback.
+ *   • THE DIRECT PORT, NOT `portTls`. `portTls` (6432) is pgBouncer with a static user list: only `db`, `postgres` and
+ *     `zps` log in there, and a role fabrika creates is refused (`08P01`, measured 2026-10-15). A contract
+ *     application's runtime role reuses its database URL's host and port, so only the direct port serves it.
+ *   • `sslmode=disable`, the one mode that connects on both service types: `postgresql:ha@18` answers `require` on the
+ *     direct port with "Server does not support SSL", and `Bun.SQL`'s `prefer` waits out its 30 s connection timeout
+ *     against a server without TLS instead of falling back. The direct port stays inside the project's network.
+ *
+ * A contract application does not connect with this: its `FABRIKA_APP_DATABASE_URL` names the service's superuser,
+ * the provisioning credential of its role family (ADR-0017, `zeropsProvisioningDatabaseUrl` in `../manifest.ts`).
+ */
+export declare const ZEROPS_SHARED_POSTGRES_CONNECTION_STRING = "${postgres_connectionString}/${postgres_dbName}?sslmode=disable";

package/types/src/namespace/errors.d.ts

@@ -0,0 +1,15 @@
+import { ProviderNamespaceError } from '@fabrika/provider-contract';
+/**
+ * Lifecycle codes this provider defines where the platform has none of its own. They are an
+ * operator-facing vocabulary, so they are stable identifiers rather than prose (backlog 72): a
+ * platform code such as `insufficientPermissions` and one of these read the same way downstream.
+ */
+export declare const ZEROPS_NAMESPACE_CANCELLED = "namespaceCancelled";
+export declare const ZEROPS_NAMESPACE_LIFECYCLE = "namespaceLifecycle";
+export declare const ZEROPS_PROXY_DEPLOY_TIMEOUT = "proxyDeployTimeout";
+export declare const ZEROPS_PROXY_DEPLOY_FAILED = "proxyDeployFailed";
+export declare const ZEROPS_SUBDOMAIN_NOT_PUBLISHED = "subdomainNotPublished";
+export declare const ZEROPS_SOURCE_RATE_LIMITED = "githubRateLimited";
+export declare const namespaceError: (code: string, message: string, retryable: boolean, detail?: string) => ProviderNamespaceError;
+/** Every namespace lifecycle failure leaves this provider as one typed, coded error. */
+export declare const asNamespaceError: (cause: unknown, mode: "provision" | "reconcile" | "update") => ProviderNamespaceError;

package/types/src/namespace/manifest.d.ts

@@ -0,0 +1,4 @@
+import { type ProviderNamespaceMember } from '@fabrika/provider-contract';
+import { type ProxyManifest } from '@fabrika/proxy-core/manifest';
+/** Compile every public member of one deployment namespace into its strict proxy manifest. */
+export declare function compileNamespaceProxyManifest(namespaceId: string, members: readonly ProviderNamespaceMember[]): ProxyManifest;

package/types/src/namespace/operator.d.ts

@@ -0,0 +1,12 @@
+import type { ProviderNamespaceOperator } from '@fabrika/provider-contract';
+import type { ZeropsNamespaceOperatorOptions } from './types';
+/**
+ * The Zerops project a namespace creates when the plan names none: `fabrika-<env>-<id>`, beside the `fabrika-<env>` that
+ * `platform install` creates for the installation, so a namespace reads as fabrika's in the Zerops GUI.
+ */
+export declare const defaultZeropsNamespaceProjectName: (namespace: {
+    readonly id: string;
+    readonly env: string;
+}) => string;
+/** Build the provider-owned namespace planning surface without any network collaborators. */
+export declare const createZeropsNamespaceOperator: (options: ZeropsNamespaceOperatorOptions) => ProviderNamespaceOperator;

package/types/src/namespace/provisioning.d.ts

@@ -0,0 +1,4 @@
+import { type ProviderNamespaceCapabilities } from '@fabrika/provider-contract';
+import type { ZeropsNamespaceOptions } from './types';
+/** Build the provider-owned namespace lifecycle capability. */
+export declare const createZeropsNamespaceCapabilities: (options: ZeropsNamespaceOptions) => ProviderNamespaceCapabilities;

package/types/src/namespace/proxy-attempt.d.ts

@@ -0,0 +1,36 @@
+import { type ProxyManifest } from '@fabrika/proxy-core/manifest';
+import { type ZeropsApi } from '../api';
+import type { Sleeper } from '../collaborators';
+import type { ZeropsSourcePort } from '../source/port';
+import type { ZeropsNamespaceTarget } from './types';
+export type ZeropsProxyApi = Pick<ZeropsApi, 'listServiceEnv' | 'putServiceEnv' | 'deleteServiceEnv' | 'createAppVersion' | 'deleteAppVersion' | 'buildAndDeployAppVersion' | 'getAppVersion'>;
+export interface ZeropsProxyRepublishInput {
+    /** The namespace's id, named in the one refusal an operator acts on: re-pin it. */
+    readonly namespaceId: string;
+    readonly target: ZeropsNamespaceTarget;
+    readonly manifest: ProxyManifest;
+    readonly source?: ZeropsSourcePort;
+    readonly api: ZeropsProxyApi;
+    readonly iamUrl: string;
+    readonly iamKey: string;
+    /** Proxy service variable → the secret of one contract application (`namespaceProxySecrets`); none without one. */
+    readonly proxySecrets?: ReadonlyMap<string, string>;
+    /** Aborts with `lease_lost` when the namespace lease goes, and with `cancel_requested` when a deploy is cancelled. */
+    readonly signal: AbortSignal;
+    readonly wait: 'started' | 'active';
+    /**
+     * Reuse the proxy's ACTIVE version when it was built from this pin with this manifest identity. A deploy and a
+     * registry change pass true; provisioning and reconcile rebuild, so an operator's repair always reaches the platform.
+     */
+    readonly reuseActive: boolean;
+    /** Persist the target; the caller fences the write on the namespace lease. */
+    readonly checkpoint: (target: ZeropsNamespaceTarget) => Promise<void>;
+    readonly boundary: () => Promise<void>;
+    readonly sleep: Sleeper;
+}
+/**
+ * Rebuild the namespace proxy with `manifest` (ADR-0044). The attempt is recorded as `proxyBuild` and never
+ * resumed: an inherited attempt not yet `triggered` is deleted, a triggered one is polled to a terminal state.
+ * A lost lease deletes nothing; a cancelled deploy leaves a triggered attempt recorded for reconciliation.
+ */
+export declare function republishProxy(input: ZeropsProxyRepublishInput): Promise<ZeropsNamespaceTarget>;

package/types/src/namespace/proxy-reads.d.ts

@@ -0,0 +1,33 @@
+import type { ProviderApprovedAccess } from '@fabrika/provider-contract';
+import type { CspOrigins } from '@fabrika/proxy-core/headers';
+import { type ProxyEndpointRow } from '@fabrika/proxy-core/manifest';
+import type { ZeropsNamespaceProxySource } from './types';
+/**
+ * What the namespace proxy of one older platform release parses of an application's manifest entry: a row, and the
+ * entry's CSP directives, each by that release's own parser.
+ */
+export interface OlderProxyReader {
+    readonly row: (row: ProxyEndpointRow) => boolean;
+    readonly csp: (csp: CspOrigins) => boolean;
+}
+/**
+ * The namespace proxies of the older releases this platform serves (ADR-0062). Control holds their parsers, as it holds
+ * their contract readers; a pin's release is not recorded, so what any of them reads is what the pin may read.
+ */
+export type OlderProxyReaders = readonly [OlderProxyReader, ...OlderProxyReader[]];
+/**
+ * What of the approved contract's manifest entry no older release's proxy parses, as the namespace publishes it: each
+ * such row by its id, and `csp` when no older proxy parses the entry's CSP (`workerSrc`, which only this release knows).
+ */
+export declare function entriesNeedingCurrentProxy(access: ProviderApprovedAccess, olderProxies: OlderProxyReaders): string[];
+/** This control plane's own proxy source, and the parsers of the older releases a pinned proxy may run. */
+export interface PlatformProxies {
+    readonly proxySource: ZeropsNamespaceProxySource;
+    readonly olderProxies: OlderProxyReaders;
+}
+/**
+ * Refuses a deploy whose approved contract holds a row or a CSP directive the namespace's pinned proxy may not read: its source is not the
+ * one this control plane deploys new placements from. `platform` is absent where this control plane manages no
+ * namespace proxy, which then has nothing to compare.
+ */
+export declare function assertNamespaceProxyReads(namespace: string, access: ProviderApprovedAccess | undefined, pinned: ZeropsNamespaceProxySource, platform: PlatformProxies | undefined): void;

package/types/src/namespace/proxy-secrets.d.ts

@@ -0,0 +1,8 @@
+import type { ProviderNamespaceMember } from '@fabrika/provider-contract';
+import { type ProxyManifest } from '@fabrika/proxy-core/manifest';
+/**
+ * The proxy service variables a manifest needs: for each contract application, the secret Caddy sends it
+ * (ADR-0022 rule 5), keyed by `proxySecretVariable`. A contract member without a secret is refused, because
+ * its application would refuse every request the proxy sends.
+ */
+export declare function namespaceProxySecrets(manifest: ProxyManifest, members: readonly ProviderNamespaceMember[]): ReadonlyMap<string, string>;

package/types/src/namespace/proxy-source.d.ts

@@ -0,0 +1,74 @@
+import { z } from 'zod';
+import type { ZeropsNamespaceProxySource } from './types';
+export declare const namespaceProxySourceSchema: z.ZodEffects<z.ZodObject<{
+    repository: z.ZodObject<{
+        owner: z.ZodString;
+        name: z.ZodEffects<z.ZodString, string, string>;
+    }, "strict", z.ZodTypeAny, {
+        name: string;
+        owner: string;
+    }, {
+        name: string;
+        owner: string;
+    }>;
+    commitSha: z.ZodString;
+    descriptor: z.ZodObject<{
+        path: z.ZodLiteral<"zerops.yaml">;
+        contents: z.ZodEffects<z.ZodString, string, string>;
+        sha256: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        sha256: string;
+        path: "zerops.yaml";
+        contents: string;
+    }, {
+        sha256: string;
+        path: "zerops.yaml";
+        contents: string;
+    }>;
+}, "strict", z.ZodTypeAny, {
+    commitSha: string;
+    repository: {
+        name: string;
+        owner: string;
+    };
+    descriptor: {
+        sha256: string;
+        path: "zerops.yaml";
+        contents: string;
+    };
+}, {
+    commitSha: string;
+    repository: {
+        name: string;
+        owner: string;
+    };
+    descriptor: {
+        sha256: string;
+        path: "zerops.yaml";
+        contents: string;
+    };
+}>, {
+    commitSha: string;
+    repository: {
+        name: string;
+        owner: string;
+    };
+    descriptor: {
+        sha256: string;
+        path: "zerops.yaml";
+        contents: string;
+    };
+}, {
+    commitSha: string;
+    repository: {
+        name: string;
+        owner: string;
+    };
+    descriptor: {
+        sha256: string;
+        path: "zerops.yaml";
+        contents: string;
+    };
+}>;
+export declare const decodeZeropsNamespaceProxySource: (value: unknown) => ZeropsNamespaceProxySource;
+export declare const verifyZeropsNamespaceProxySource: (source: ZeropsNamespaceProxySource) => Promise<void>;

package/types/src/namespace/topology.d.ts

@@ -0,0 +1,9 @@
+import type { ProviderDeploymentNamespace } from '@fabrika/provider-contract';
+import type { ZeropsNamespacePolicy, ZeropsNamespacePresetInput, ZeropsNamespaceTarget, ZeropsNamespaceTopology } from './types';
+export declare const PROXY_TYPE = "alpine@3.21";
+/** A preset's project and service policy, without the proxy source pin (ADR-0045). */
+export declare const zeropsNamespacePolicy: (input: Omit<ZeropsNamespacePresetInput, "proxySource">) => ZeropsNamespacePolicy;
+export declare const zeropsNamespacePreset: (input: ZeropsNamespacePresetInput) => ZeropsNamespaceTarget;
+export declare const projectMarker: (namespace: ProviderDeploymentNamespace) => string;
+/** Compile the one project and its namespace-owned services without depending on private deploy code. */
+export declare const compileZeropsNamespaceTopology: (namespace: ProviderDeploymentNamespace, target: ZeropsNamespacePolicy) => ZeropsNamespaceTopology;

package/types/src/namespace/types.d.ts

@@ -0,0 +1,99 @@
+import type { ProviderNamespaceHost } from '@fabrika/provider-contract';
+import type { ZeropsApi, ZeropsProjectMode } from '../api';
+import type { Sleeper } from '../collaborators';
+import type { ZeropsArtifactSourceDescriptor } from '../manifest';
+import type { ZeropsSourceRepository } from '../source';
+import type { ZeropsSourcePort } from '../source/port';
+import type { ZeropsSourceTarget } from '../types';
+export type ZeropsNamespacePublicAccess = 'custom-domain' | 'zerops-subdomain';
+export interface ZeropsNamespaceProxySource {
+    readonly repository: ZeropsSourceRepository;
+    readonly commitSha: string;
+    readonly descriptor: ZeropsArtifactSourceDescriptor;
+}
+/** The proxy attempt in flight (ADR-0044): a version not `triggered` is deleted, a triggered one is polled. */
+export interface ZeropsNamespaceProxyBuild {
+    readonly appVersionId: string;
+    readonly triggered: boolean;
+    readonly manifestSha256?: string;
+}
+export interface ZeropsNamespaceProxyDeployment {
+    readonly manifestSha256?: string;
+    readonly appVersionId: string;
+    readonly repository: ZeropsSourceRepository;
+    readonly commitSha: string;
+    readonly descriptorSha256: string;
+}
+export type ZeropsNamespacePostgres = {
+    readonly type: 'postgresql:ha@18';
+    readonly profile?: 'oltp-staging' | 'oltp-production' | 'oltp-enterprise' | 'olap-production' | 'writeheavy-production';
+} | {
+    readonly type: 'postgresql:single@18';
+    readonly profile?: 'oltp-hobby' | 'oltp-staging' | 'oltp-production' | 'olap-production' | 'writeheavy-production';
+};
+/**
+ * Provider-owned namespace state. Optional fields are durable progress checkpoints; values that are
+ * absent are resolved by `normalize()` before a mutation starts.
+ */
+export interface ZeropsNamespaceTarget {
+    readonly proxySource: ZeropsNamespaceProxySource;
+    readonly proxyBuild?: ZeropsNamespaceProxyBuild;
+    readonly proxyDeployment?: ZeropsNamespaceProxyDeployment;
+    readonly projectName?: string;
+    readonly corePackage?: ZeropsProjectMode;
+    readonly publicAccess?: ZeropsNamespacePublicAccess;
+    readonly postgres?: ZeropsNamespacePostgres;
+    readonly managed?: boolean;
+    readonly projectId?: string;
+    readonly proxyServiceId?: string;
+    readonly postgresServiceId?: string;
+    readonly proxyConfigured?: boolean;
+    readonly proxyBaselineSequence?: number;
+    readonly proxyAppVersionId?: string;
+    /** The hosts the published proxy answers on, recorded once so a namespace read needs no platform call. */
+    readonly proxyHosts?: readonly ProviderNamespaceHost[];
+    readonly ready?: boolean;
+}
+export type ZeropsNamespacePolicy = Omit<ZeropsNamespaceTarget, 'proxySource'>;
+export interface NormalizedZeropsNamespaceTarget extends ZeropsNamespaceTarget {
+    readonly projectName: string;
+    readonly corePackage: ZeropsProjectMode;
+    readonly publicAccess: ZeropsNamespacePublicAccess;
+    readonly managed: boolean;
+    readonly ready: boolean;
+}
+export interface ZeropsNamespaceOptions {
+    readonly proxySource: ZeropsNamespaceProxySource;
+    readonly source?: ZeropsSourcePort;
+    readonly clientId: string;
+    /** Public IAM origin reachable from an app project. */
+    readonly iamUrl: string;
+    /** Same credential IAM receives as `FABRIKA_IAM_PROXY_KEY`. */
+    readonly iamKey: string;
+    readonly api: ZeropsApi;
+    readonly sleep?: Sleeper;
+}
+export interface ZeropsNamespaceTopology {
+    readonly source: ZeropsSourceTarget;
+    readonly createYaml: string;
+    readonly servicesProvisionYaml: string;
+    readonly servicesSteadyYaml: string;
+}
+export interface ZeropsNamespacePresetInput {
+    readonly proxySource: ZeropsNamespaceProxySource;
+    readonly preset: 'cheap' | 'mid' | 'full';
+    readonly env: string;
+    readonly projectName: string;
+    readonly corePackage?: ZeropsProjectMode;
+    readonly publicAccess?: ZeropsNamespacePublicAccess;
+    readonly postgres?: ZeropsNamespacePostgres;
+}
+export interface ZeropsNamespaceOperatorOptions {
+    readonly proxySource: ZeropsNamespaceProxySource;
+}
+export interface ZeropsNamespacePlanOptions {
+    readonly projectName?: string;
+    readonly corePackage?: ZeropsProjectMode;
+    readonly publicAccess?: ZeropsNamespacePublicAccess;
+    readonly postgres?: ZeropsNamespacePostgres;
+}