@spacefast/common 0.0.6 → 0.0.8

package/dist/contracts/operations.d.ts

@@ -1,4 +1,114 @@
 import { z } from "zod";
+export declare const userOperationKindSchema: z.ZodEnum<{
+    approval: "approval";
+    version_finalize: "version_finalize";
+    version_promote_live: "version_promote_live";
+    version_delete: "version_delete";
+    build_start: "build_start";
+    domain_check: "domain_check";
+    domain_ssl_retry: "domain_ssl_retry";
+    domain_registration_submit: "domain_registration_submit";
+    domain_transfer_submit: "domain_transfer_submit";
+    domain_zone_publish: "domain_zone_publish";
+    domain_dns_apply: "domain_dns_apply";
+    domain_lifecycle: "domain_lifecycle";
+    variable_cascade: "variable_cascade";
+    webhook_deliver: "webhook_deliver";
+    integration_release: "integration_release";
+    agent_run: "agent_run";
+}>;
+export type UserOperationKind = z.infer<typeof userOperationKindSchema>;
+export declare const UserOperationSchema: z.ZodObject<{
+    id: z.ZodString;
+    status: z.ZodEnum<{
+        failed: "failed";
+        canceled: "canceled";
+        queued: "queued";
+        running: "running";
+        succeeded: "succeeded";
+    }>;
+    resources: z.ZodArray<z.ZodObject<{
+        type: z.ZodString;
+        id: z.ZodString;
+    }, z.core.$strip>>;
+    progress: z.ZodOptional<z.ZodObject<{
+        total: z.ZodNumber;
+        completed: z.ZodNumber;
+        failed: z.ZodNumber;
+    }, z.core.$strip>>;
+    diagnostics: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        code: z.ZodString;
+        severity: z.ZodEnum<{
+            info: "info";
+            warning: "warning";
+            error: "error";
+        }>;
+        message: z.ZodString;
+        path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        provider: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+            registrar: "registrar";
+            wpcloud: "wpcloud";
+            dns: "dns";
+            runtime: "runtime";
+        }>>>;
+        details: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+        fix: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        retryable: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+    }, z.core.$strip>>>;
+    createdAt: z.ZodString;
+    finishedAt: z.ZodOptional<z.ZodString>;
+    kind: z.ZodEnum<{
+        approval: "approval";
+        version_finalize: "version_finalize";
+        version_promote_live: "version_promote_live";
+        version_delete: "version_delete";
+        build_start: "build_start";
+        domain_check: "domain_check";
+        domain_ssl_retry: "domain_ssl_retry";
+        domain_registration_submit: "domain_registration_submit";
+        domain_transfer_submit: "domain_transfer_submit";
+        domain_zone_publish: "domain_zone_publish";
+        domain_dns_apply: "domain_dns_apply";
+        domain_lifecycle: "domain_lifecycle";
+        variable_cascade: "variable_cascade";
+        webhook_deliver: "webhook_deliver";
+        integration_release: "integration_release";
+        agent_run: "agent_run";
+    }>;
+    versionSource: z.ZodOptional<z.ZodEnum<{
+        direct_upload: "direct_upload";
+        git: "git";
+        settings: "settings";
+    }>>;
+    integrationRelease: z.ZodOptional<z.ZodObject<{
+        environment: z.ZodEnum<{
+            production: "production";
+            preview: "preview";
+            development: "development";
+        }>;
+    }, z.core.$strip>>;
+    agentRun: z.ZodOptional<z.ZodObject<{
+        state: z.ZodEnum<{
+            failed: "failed";
+            completed: "completed";
+            canceled: "canceled";
+            queued: "queued";
+            running: "running";
+            approval_required: "approval_required";
+        }>;
+        tool: z.ZodString;
+        mode: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    approval: z.ZodOptional<z.ZodObject<{
+        decision: z.ZodNullable<z.ZodEnum<{
+            deny: "deny";
+            approve: "approve";
+        }>>;
+        decidedAt: z.ZodNullable<z.ZodString>;
+        expiresAt: z.ZodString;
+        consumedAt: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
 export declare const operationListQuerySchema: z.ZodObject<{
     limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
     cursor: z.ZodOptional<z.ZodString>;
@@ -8,7 +118,6 @@ export declare const operationListQuerySchema: z.ZodObject<{
 export declare const operationListResponseSchema: z.ZodObject<{
     data: z.ZodArray<z.ZodObject<{
         id: z.ZodString;
-        kind: z.ZodString;
         status: z.ZodEnum<{
             failed: "failed";
             canceled: "canceled";
@@ -46,6 +155,57 @@ export declare const operationListResponseSchema: z.ZodObject<{
         }, z.core.$strip>>>;
         createdAt: z.ZodString;
         finishedAt: z.ZodOptional<z.ZodString>;
+        kind: z.ZodEnum<{
+            approval: "approval";
+            version_finalize: "version_finalize";
+            version_promote_live: "version_promote_live";
+            version_delete: "version_delete";
+            build_start: "build_start";
+            domain_check: "domain_check";
+            domain_ssl_retry: "domain_ssl_retry";
+            domain_registration_submit: "domain_registration_submit";
+            domain_transfer_submit: "domain_transfer_submit";
+            domain_zone_publish: "domain_zone_publish";
+            domain_dns_apply: "domain_dns_apply";
+            domain_lifecycle: "domain_lifecycle";
+            variable_cascade: "variable_cascade";
+            webhook_deliver: "webhook_deliver";
+            integration_release: "integration_release";
+            agent_run: "agent_run";
+        }>;
+        versionSource: z.ZodOptional<z.ZodEnum<{
+            direct_upload: "direct_upload";
+            git: "git";
+            settings: "settings";
+        }>>;
+        integrationRelease: z.ZodOptional<z.ZodObject<{
+            environment: z.ZodEnum<{
+                production: "production";
+                preview: "preview";
+                development: "development";
+            }>;
+        }, z.core.$strip>>;
+        agentRun: z.ZodOptional<z.ZodObject<{
+            state: z.ZodEnum<{
+                failed: "failed";
+                completed: "completed";
+                canceled: "canceled";
+                queued: "queued";
+                running: "running";
+                approval_required: "approval_required";
+            }>;
+            tool: z.ZodString;
+            mode: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        approval: z.ZodOptional<z.ZodObject<{
+            decision: z.ZodNullable<z.ZodEnum<{
+                deny: "deny";
+                approve: "approve";
+            }>>;
+            decidedAt: z.ZodNullable<z.ZodString>;
+            expiresAt: z.ZodString;
+            consumedAt: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>>;
     }, z.core.$strip>>;
     pagination: z.ZodObject<{
         nextCursor: z.ZodNullable<z.ZodString>;

package/dist/contracts/operations.js

@@ -1,5 +1,53 @@
 import { z } from "zod";
 import { AsyncOperationSchema, CursorPaginationSchema, cursorListQuerySchema } from "./common.js";
+export const userOperationKindSchema = z.enum([
+    "version_finalize",
+    "version_promote_live",
+    "version_delete",
+    "build_start",
+    "domain_check",
+    "domain_ssl_retry",
+    "domain_registration_submit",
+    "domain_transfer_submit",
+    "domain_zone_publish",
+    "domain_dns_apply",
+    "domain_lifecycle",
+    "variable_cascade",
+    "webhook_deliver",
+    "integration_release",
+    "agent_run",
+    "approval",
+]);
+export const UserOperationSchema = AsyncOperationSchema.extend({
+    kind: userOperationKindSchema,
+    versionSource: z
+        .enum(["direct_upload", "git", "settings"])
+        .optional()
+        .describe("Version provenance for version operations; settings marks a settings publish, while direct_upload and git mark content publishes. Omitted for legacy rows."),
+    integrationRelease: z
+        .object({
+        environment: z.enum(["production", "preview", "development"]),
+    })
+        .optional()
+        .describe("Release environment for an integration tag pointer flip."),
+    agentRun: z
+        .object({
+        state: z.enum(["queued", "running", "approval_required", "completed", "failed", "canceled"]),
+        tool: z.string(),
+        mode: z.string().optional(),
+    })
+        .optional()
+        .describe("Authoritative agent execution state and the tool invocation that produced it."),
+    approval: z
+        .object({
+        decision: z.enum(["approve", "deny"]).nullable(),
+        decidedAt: z.string().datetime().nullable(),
+        expiresAt: z.string().datetime(),
+        consumedAt: z.string().datetime().nullable(),
+    })
+        .optional()
+        .describe("Current approval decision and lifecycle timestamps from the approval authority."),
+});
 export const operationListQuerySchema = cursorListQuerySchema.extend({
     resourceType: z
         .string()
@@ -9,6 +57,6 @@ export const operationListQuerySchema = cursorListQuerySchema.extend({
     resourceId: z.string().min(1).optional().describe("Filter to operations touching one resource."),
 });
 export const operationListResponseSchema = z.object({
-    data: z.array(AsyncOperationSchema),
+    data: z.array(UserOperationSchema),
     pagination: CursorPaginationSchema,
 });

package/dist/contracts/platform.d.ts

@@ -231,6 +231,12 @@ export declare const runtimeCertificateMutationResponseSchema: z.ZodObject<{
     }, z.core.$strip>>;
     raw: z.ZodRecord<z.ZodString, z.ZodUnknown>;
 }, z.core.$strip>;
+export declare const runtimeCertificateValidationResponseSchema: z.ZodObject<{
+    valid: z.ZodBoolean;
+    errors: z.ZodArray<z.ZodString>;
+    warnings: z.ZodArray<z.ZodString>;
+    validations: z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
 export declare const runtimeCertificateActivateSchema: z.ZodObject<{
     domains: z.ZodOptional<z.ZodArray<z.ZodString>>;
 }, z.core.$strip>;

package/dist/contracts/platform.js

@@ -141,6 +141,12 @@ export const runtimeCertificateMutationResponseSchema = z.object({
     certificate: runtimeCertificateSchema.nullable(),
     raw: z.record(z.string(), z.unknown()),
 });
+export const runtimeCertificateValidationResponseSchema = z.object({
+    valid: z.boolean(),
+    errors: z.array(z.string()),
+    warnings: z.array(z.string()),
+    validations: z.record(z.string(), z.record(z.string(), z.unknown())),
+});
 export const runtimeCertificateActivateSchema = z.object({
     domains: z.array(z.string()).optional(),
 });

package/dist/contracts/publishes.d.ts

@@ -0,0 +1,130 @@
+import { z } from "zod";
+export declare const publishStates: readonly ["awaiting_upload", "uploaded", "parked", "materializing", "succeeded", "failed", "cancelled", "expired"];
+export declare const publishStateSchema: z.ZodEnum<{
+    failed: "failed";
+    expired: "expired";
+    uploaded: "uploaded";
+    succeeded: "succeeded";
+    materializing: "materializing";
+    awaiting_upload: "awaiting_upload";
+    parked: "parked";
+    cancelled: "cancelled";
+}>;
+export type PublishState = z.infer<typeof publishStateSchema>;
+export declare const publishIdSchema: z.ZodCustom<`pub_${string}`, `pub_${string}`>;
+export declare const publishAdmissionSchema: z.ZodObject<{
+    id: z.ZodCustom<`pub_${string}`, `pub_${string}`>;
+    idempotencyKey: z.ZodString;
+    requestFingerprint: z.ZodString;
+}, z.core.$strip>;
+export declare const publishSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    id: z.ZodCustom<`pub_${string}`, `pub_${string}`>;
+    state: z.ZodLiteral<"awaiting_upload">;
+    target: z.ZodOptional<z.ZodObject<{
+        spaceId: z.ZodCustom<`spc_${string}`, `spc_${string}`>;
+        baseVersionId: z.ZodNullable<z.ZodCustom<`ver_${string}`, `ver_${string}`>>;
+    }, z.core.$strip>>;
+    counts: z.ZodOptional<z.ZodObject<{
+        received: z.ZodNumber;
+        missing: z.ZodNumber;
+    }, z.core.$strip>>;
+    expiresAt: z.ZodOptional<z.ZodString>;
+    upload: z.ZodOptional<z.ZodObject<{
+        missing: z.ZodArray<z.ZodObject<{
+            path: z.ZodString;
+            sha256: z.ZodNullable<z.ZodString>;
+            size: z.ZodNumber;
+            url: z.ZodString;
+            headers: z.ZodRecord<z.ZodString, z.ZodString>;
+            expiresAt: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
+    id: z.ZodCustom<`pub_${string}`, `pub_${string}`>;
+    state: z.ZodLiteral<"uploaded">;
+}, z.core.$strip>, z.ZodObject<{
+    id: z.ZodCustom<`pub_${string}`, `pub_${string}`>;
+    state: z.ZodLiteral<"parked">;
+    reason: z.ZodLiteral<"capacity">;
+    queuePosition: z.ZodOptional<z.ZodNumber>;
+    nextCheckAfterSeconds: z.ZodNumber;
+    actions: z.ZodTuple<[z.ZodObject<{
+        kind: z.ZodLiteral<"cancel_publish">;
+        publishId: z.ZodCustom<`pub_${string}`, `pub_${string}`>;
+    }, z.core.$strip>], null>;
+}, z.core.$strip>, z.ZodObject<{
+    id: z.ZodCustom<`pub_${string}`, `pub_${string}`>;
+    state: z.ZodLiteral<"materializing">;
+    operation: z.ZodObject<{
+        id: z.ZodCustom<`op_${string}`, `op_${string}`>;
+        kind: z.ZodLiteral<"publish.finalize">;
+        status: z.ZodEnum<{
+            queued: "queued";
+            running: "running";
+        }>;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    id: z.ZodCustom<`pub_${string}`, `pub_${string}`>;
+    state: z.ZodLiteral<"succeeded">;
+    outcome: z.ZodEnum<{
+        created: "created";
+        unchanged: "unchanged";
+        updated: "updated";
+    }>;
+    capturedBaseVersionId: z.ZodOptional<z.ZodNullable<z.ZodCustom<`ver_${string}`, `ver_${string}`>>>;
+    result: z.ZodObject<{
+        space: z.ZodObject<{
+            id: z.ZodCustom<`spc_${string}`, `spc_${string}`>;
+            liveUrl: z.ZodString;
+        }, z.core.$strip>;
+        version: z.ZodObject<{
+            id: z.ZodCustom<`ver_${string}`, `ver_${string}`>;
+            immutableUrl: z.ZodString;
+        }, z.core.$strip>;
+        live: z.ZodObject<{
+            previousVersionId: z.ZodNullable<z.ZodCustom<`ver_${string}`, `ver_${string}`>>;
+            versionId: z.ZodCustom<`ver_${string}`, `ver_${string}`>;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    id: z.ZodCustom<`pub_${string}`, `pub_${string}`>;
+    state: z.ZodLiteral<"failed">;
+    errorCode: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    id: z.ZodCustom<`pub_${string}`, `pub_${string}`>;
+    state: z.ZodLiteral<"cancelled">;
+}, z.core.$strip>, z.ZodObject<{
+    id: z.ZodCustom<`pub_${string}`, `pub_${string}`>;
+    state: z.ZodLiteral<"expired">;
+}, z.core.$strip>], "state">;
+export type Publish = z.infer<typeof publishSchema>;
+export type PublishAdmission = z.infer<typeof publishAdmissionSchema>;
+export type DurablePublish = Publish & PublishAdmission;
+export type PublishByState<State extends PublishState> = Extract<DurablePublish, {
+    state: State;
+}>;
+declare const allowedTransitions: {
+    readonly awaiting_upload: readonly ["uploaded", "cancelled", "expired"];
+    readonly uploaded: readonly ["parked", "materializing", "cancelled", "expired"];
+    readonly parked: readonly ["materializing", "cancelled", "expired"];
+    readonly materializing: readonly ["succeeded", "failed", "cancelled", "expired"];
+    readonly succeeded: readonly [];
+    readonly failed: readonly [];
+    readonly cancelled: readonly [];
+    readonly expired: readonly [];
+};
+export type NextPublishState<State extends PublishState> = (typeof allowedTransitions)[State][number];
+export declare function canTransitionPublish<From extends PublishState>(from: From, to: PublishState): to is NextPublishState<From>;
+export declare function transitionPublish<From extends PublishState, Next extends DurablePublish>(publish: PublishByState<From>, next: Next & (Next["state"] extends NextPublishState<From> ? unknown : never)): Next;
+export type PublishAdmissionResult<Existing extends PublishAdmission = PublishAdmission> = {
+    outcome: "created";
+    publish: PublishAdmission;
+} | {
+    outcome: "replayed";
+    publish: Existing;
+} | {
+    outcome: "conflict";
+    publish: Existing;
+};
+export declare function convergePublishAdmission<Existing extends PublishAdmission>(existing: Existing | undefined, attempted: PublishAdmission): PublishAdmissionResult<Existing>;
+export {};

package/dist/contracts/publishes.js

@@ -0,0 +1,145 @@
+import { z } from "zod";
+import { registeredIdSchema } from "./ids.js";
+export const publishStates = [
+    "awaiting_upload",
+    "uploaded",
+    "parked",
+    "materializing",
+    "succeeded",
+    "failed",
+    "cancelled",
+    "expired",
+];
+export const publishStateSchema = z.enum(publishStates);
+export const publishIdSchema = registeredIdSchema("pub");
+const spaceIdSchema = registeredIdSchema("spc");
+const versionIdSchema = registeredIdSchema("ver");
+export const publishAdmissionSchema = z.object({
+    id: publishIdSchema,
+    idempotencyKey: z.string().min(1),
+    requestFingerprint: z.string().min(1),
+});
+const cancellableActionSchema = z.object({
+    kind: z.literal("cancel_publish"),
+    publishId: publishIdSchema,
+});
+export const publishSchema = z.discriminatedUnion("state", [
+    z.object({
+        id: publishIdSchema,
+        state: z.literal("awaiting_upload"),
+        target: z
+            .object({
+            spaceId: spaceIdSchema,
+            baseVersionId: versionIdSchema.nullable(),
+        })
+            .optional(),
+        counts: z
+            .object({
+            received: z.number().int().nonnegative(),
+            missing: z.number().int().positive(),
+        })
+            .optional(),
+        expiresAt: z.string().datetime().optional(),
+        upload: z.object({
+            missing: z.array(z.object({
+                path: z.string(),
+                sha256: z.string().regex(/^[0-9a-f]{64}$/).nullable(),
+                size: z.number().int().nonnegative(),
+                url: z.string().url(),
+                headers: z.record(z.string(), z.string()),
+                expiresAt: z.string().datetime(),
+            })).min(1),
+        }).optional(),
+    }).refine((publish) => publish.counts === undefined ||
+        publish.upload === undefined ||
+        publish.counts.missing === publish.upload.missing.length, {
+        message: "Upload instructions must match the missing upload count.",
+        path: ["upload", "missing"],
+    }).refine((publish) => publish.counts !== undefined || publish.upload !== undefined, {
+        message: "An awaiting_upload publish must carry counts or upload instructions.",
+        path: ["counts"],
+    }),
+    z.object({ id: publishIdSchema, state: z.literal("uploaded") }),
+    z
+        .object({
+        id: publishIdSchema,
+        state: z.literal("parked"),
+        reason: z.literal("capacity"),
+        queuePosition: z.number().int().positive().optional(),
+        nextCheckAfterSeconds: z.number().int().positive(),
+        actions: z.tuple([cancellableActionSchema]),
+    })
+        .refine((publish) => publish.actions.every((action) => action.publishId === publish.id), {
+        message: "Cancel actions must reference the enclosing publish.",
+        path: ["actions"],
+    }),
+    z.object({
+        id: publishIdSchema,
+        state: z.literal("materializing"),
+        operation: z.object({
+            id: registeredIdSchema("op"),
+            kind: z.literal("publish.finalize"),
+            status: z.enum(["queued", "running"]),
+        }),
+    }),
+    z.object({
+        id: publishIdSchema,
+        state: z.literal("succeeded"),
+        outcome: z.enum(["created", "updated", "unchanged"]),
+        capturedBaseVersionId: versionIdSchema.nullable().optional(),
+        result: z.object({
+            space: z.object({ id: spaceIdSchema, liveUrl: z.string().url() }),
+            version: z.object({ id: versionIdSchema, immutableUrl: z.string().url() }),
+            live: z.object({
+                previousVersionId: versionIdSchema.nullable(),
+                versionId: versionIdSchema,
+            }),
+        }),
+    }),
+    z.object({ id: publishIdSchema, state: z.literal("failed"), errorCode: z.string().min(1) }),
+    z.object({ id: publishIdSchema, state: z.literal("cancelled") }),
+    z.object({ id: publishIdSchema, state: z.literal("expired") }),
+]);
+// Cancellation may win during materialization only before the Version exists;
+// afterwards it is not cancelable and the outcome is unchanged.
+const allowedTransitions = {
+    awaiting_upload: ["uploaded", "cancelled", "expired"],
+    uploaded: ["parked", "materializing", "cancelled", "expired"],
+    parked: ["materializing", "cancelled", "expired"],
+    materializing: ["succeeded", "failed", "cancelled", "expired"],
+    succeeded: [],
+    failed: [],
+    cancelled: [],
+    expired: [],
+};
+export function canTransitionPublish(from, to) {
+    return allowedTransitions[from].some((candidate) => candidate === to);
+}
+export function transitionPublish(publish, next) {
+    if (publish.id !== next.id ||
+        publish.idempotencyKey !== next.idempotencyKey ||
+        publish.requestFingerprint !== next.requestFingerprint) {
+        throw new Error("A publish transition cannot change the durable publish identity.");
+    }
+    if (!canTransitionPublish(publish.state, next.state)) {
+        throw new Error(`Invalid publish transition: ${publish.state} -> ${next.state}`);
+    }
+    // Project through the wire schema so fields from the previous variant (e.g. a
+    // parked `reason` spread into a materializing publish) never leak downstream.
+    return {
+        ...publishSchema.parse(next),
+        idempotencyKey: next.idempotencyKey,
+        requestFingerprint: next.requestFingerprint,
+    };
+}
+export function convergePublishAdmission(existing, attempted) {
+    if (existing === undefined)
+        return { outcome: "created", publish: attempted };
+    if (existing.idempotencyKey !== attempted.idempotencyKey) {
+        throw new Error("Admission convergence requires one idempotency key.");
+    }
+    if (existing.requestFingerprint !== attempted.requestFingerprint) {
+        return { outcome: "conflict", publish: existing };
+    }
+    return { outcome: "replayed", publish: existing };
+}

package/dist/contracts/repository-connections.d.ts

@@ -23,6 +23,9 @@ export declare const RepositoryConnectionSchema: z.ZodObject<{
         connected: "connected";
     }>;
     repositoryId: z.ZodNullable<z.ZodString>;
+    installationId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    cloneUrlConfigured: z.ZodDefault<z.ZodBoolean>;
+    upstreamUrlConfigured: z.ZodDefault<z.ZodBoolean>;
     repositoryName: z.ZodString;
     repositoryFullName: z.ZodString;
     defaultBranch: z.ZodString;

package/dist/contracts/repository-connections.js

@@ -15,6 +15,19 @@ export const RepositoryConnectionSchema = z.object({
     provider: gitProvider.describe("Git host family for the repository connection."),
     connectionType: repositoryConnectionTypeSchema,
     repositoryId: z.string().nullable(),
+    installationId: z
+        .string()
+        .nullable()
+        .default(null)
+        .describe("Repository app installation id, when configured."),
+    cloneUrlConfigured: z
+        .boolean()
+        .default(false)
+        .describe("Whether a repository clone URL is configured."),
+    upstreamUrlConfigured: z
+        .boolean()
+        .default(false)
+        .describe("Whether an upstream repository URL is configured."),
     repositoryName: z.string(),
     repositoryFullName: z.string(),
     defaultBranch: z.string(),

package/dist/contracts/resources.d.ts

@@ -38,6 +38,7 @@ export declare const ChannelPointerSchema: z.ZodObject<{
     updatedAt: z.ZodString;
 }, z.core.$strip>;
 export type ChannelPointer = z.infer<typeof ChannelPointerSchema>;
+export declare const spaceSettingsDigestSchema: z.ZodString;
 export declare const SpaceSchema: z.ZodObject<{
     id: z.ZodString;
     tenantId: z.ZodString;
@@ -221,6 +222,7 @@ export declare const SpaceSchema: z.ZodObject<{
             noscript: z.ZodOptional<z.ZodArray<z.ZodString>>;
         }, z.core.$strip>>;
     }, z.core.$strip>>;
+    settingsDigest: z.ZodString;
     noindex: z.ZodBoolean;
     policy: z.ZodNullable<z.ZodObject<{
         rules: z.ZodDefault<z.ZodArray<z.ZodObject<{

package/dist/contracts/resources.js

@@ -49,6 +49,13 @@ export const ChannelPointerSchema = z
         });
     }
 });
+// The versioned-settings CAS token: always the lowercase hex sha256 the
+// control plane computes over canonical {config, title}. Shared by the Space
+// resource (`settingsDigest`) and the PATCH guard (`baseSettingsDigest`) so a
+// caller can never persist an arbitrary string as a "digest".
+export const spaceSettingsDigestSchema = z
+    .string()
+    .regex(/^[0-9a-f]{64}$/, "must be a 64-character lowercase hex sha256 digest");
 export const SpaceSchema = z.object({
     id: z.string(),
     tenantId: z.string(),
@@ -61,8 +68,8 @@ export const SpaceSchema = z.object({
     title: z.string(),
     status: spaceStatus.describe("Operation-lifecycle status. Serving state is the separate `disabled` axis."),
     // Serving axis, distinct from the operation-lifecycle state: set whenever
-    // the space is dark. A disabled space can still be moving. Malware takedowns
-    // are `abuse_takedown` with `details.source = "malware_scan"`.
+    // the space is dark. A disabled space can still be moving. Confirmed scan
+    // takedowns use `abuse_takedown`; verdict and claim state are separate axes.
     disabled: z
         .object({
         at: z.string().datetime().nullable(),
@@ -122,6 +129,7 @@ export const SpaceSchema = z.object({
     config: spaceConfigSchema
         .nullable()
         .describe("Stored SpaceConfig overlay applied over the live version's sf.jsonc; null when nothing is overridden."),
+    settingsDigest: spaceSettingsDigestSchema.describe("CAS token for versioned settings writes (digest over title + config overlay). Send it back as baseSettingsDigest on PATCH to get compare-and-swap semantics."),
     noindex: z
         .boolean()
         .describe("When true, the live production hostnames serve platform noindex directives. Immutable version and preview hostnames are always noindex regardless of this setting."),

package/dist/contracts/runtime-api.d.ts

@@ -144,6 +144,7 @@ export declare const runtimeVersionFinalizeRequestSchema: z.ZodObject<{
                 auth: z.ZodOptional<z.ZodBoolean>;
                 env: z.ZodOptional<z.ZodBoolean>;
                 realtime: z.ZodOptional<z.ZodBoolean>;
+                logging: z.ZodOptional<z.ZodBoolean>;
             }, z.core.$strip>>>;
             db: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
         }, z.core.$strip>>>;
@@ -157,6 +158,7 @@ export declare const runtimeVersionFinalizeRequestSchema: z.ZodObject<{
                 auth: z.ZodOptional<z.ZodBoolean>;
                 env: z.ZodOptional<z.ZodBoolean>;
                 realtime: z.ZodOptional<z.ZodBoolean>;
+                logging: z.ZodOptional<z.ZodBoolean>;
             }, z.core.$strip>>>;
             db: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
         }, z.core.$strip>>>;

package/dist/contracts/runtime-api.js

@@ -271,6 +271,7 @@ const runtimeZeroEndpointCapabilitiesSchema = z
     auth: z.boolean().optional(),
     env: z.boolean().optional(),
     realtime: z.boolean().optional(),
+    logging: z.boolean().optional(),
 })
     .default({});
 const runtimeZeroEndpointSchema = z.object({