@spacefast/common 0.0.12 → 0.0.17

package/dist/contracts/pages.js

@@ -1,15 +1,14 @@
 import { z } from "zod";
-export const SITE_PAGE_IDS = ["404", "password", "denied", "login", "index", "preview"];
+export const SITE_PAGE_IDS = ["404", "denied", "access", "index", "preview"];
 export const sitePageIdSchema = z.enum(SITE_PAGE_IDS);
-export const ROUTE_PAGE_IDS = ["404", "password", "denied", "login"];
+export const ROUTE_PAGE_IDS = ["404", "denied", "access"];
 export const routePageIdSchema = z.enum(ROUTE_PAGE_IDS);
-export const CUSTOM_PAGE_IDS = ["404", "password", "denied", "index", "preview"];
+export const CUSTOM_PAGE_IDS = ["404", "denied", "access", "index", "preview"];
 export const customPageIdSchema = z.enum(CUSTOM_PAGE_IDS);
 export const PLATFORM_PAGE_IDS = [
     "undeployed",
     "suspended",
     "legal",
-    "visit-cap",
     "gone",
     "runtime-error",
     "rate-limited",
@@ -21,9 +20,9 @@ export const PLATFORM_PAGE_IDS = [
 export const platformPageIdSchema = z.enum(PLATFORM_PAGE_IDS);
 export const PAGE_ELEMENTS = [
     "sf-content",
-    "sf-password-form",
-    "sf-login",
     "sf-denial-context",
+    "sf-access-status",
+    "sf-access-lanes",
     "sf-page-path",
     "sf-page-title",
     "sf-page-summary",
@@ -37,42 +36,39 @@ export const PAGE_CATALOG = {
     "404": {
         id: "404",
         status: 404,
-        cacheControl: "public, max-age=0, s-maxage=60, must-revalidate",
+        cacheControl: "public, max-age=0, s-maxage=600, stale-while-revalidate=60",
         noindex: false,
         customTemplate: true,
     },
-    password: {
-        id: "password",
-        status: 401,
-        cacheControl: "private, no-store",
-        noindex: true,
-        customTemplate: true,
-    },
     denied: {
         id: "denied",
         status: 403,
         cacheControl: "private, no-store",
         noindex: true,
-        customTemplate: true,
+        customTemplate: false,
     },
-    login: {
-        id: "login",
-        status: 401,
+    // The visitor access page: the deny surface WITH lanes (sign in, SSO,
+    // password, request an invite). Rendered by the runtime at the requested URL;
+    // publishers may fully retheme it — the runtime injects the functional lane
+    // blocks into the sf-access-* slots so forms and states stay correct.
+    access: {
+        id: "access",
+        status: 403,
         cacheControl: "private, no-store",
         noindex: true,
-        customTemplate: false,
+        customTemplate: true,
     },
     index: {
         id: "index",
         status: 200,
-        cacheControl: "public, max-age=0, s-maxage=60, must-revalidate",
+        cacheControl: "public, max-age=0, s-maxage=600, stale-while-revalidate=60",
         noindex: false,
         customTemplate: true,
     },
     preview: {
         id: "preview",
         status: 200,
-        cacheControl: "public, max-age=0, s-maxage=60, must-revalidate",
+        cacheControl: "public, max-age=0, s-maxage=600, stale-while-revalidate=60",
         noindex: false,
         customTemplate: true,
     },

package/dist/contracts/plan-policy.d.ts

@@ -1,10 +1,8 @@
 import { z } from "zod";
-export declare const PLAN_DISABLED_BEHAVIOR_CODES: readonly ["free_external_proxy_disabled", "free_headers_basic_auth_disabled", "routing_rules_over_plan", "immutable_version_requires_login"];
+export declare const PLAN_DISABLED_BEHAVIOR_CODES: readonly ["free_external_proxy_disabled", "routing_rules_over_plan"];
 export declare const planDisabledBehaviorSchema: z.ZodObject<{
     code: z.ZodEnum<{
         free_external_proxy_disabled: "free_external_proxy_disabled";
-        free_headers_basic_auth_disabled: "free_headers_basic_auth_disabled";
-        immutable_version_requires_login: "immutable_version_requires_login";
         routing_rules_over_plan: "routing_rules_over_plan";
     }>;
     behavior: z.ZodString;
@@ -12,7 +10,6 @@ export declare const planDisabledBehaviorSchema: z.ZodObject<{
         warning: "warning";
         ignored: "ignored";
         platform_page: "platform_page";
-        login_redirect: "login_redirect";
     }>;
 }, z.core.$strip>;
 export type PlanDisabledBehavior = z.infer<typeof planDisabledBehaviorSchema>;
@@ -41,7 +38,6 @@ export declare const PlanPolicyResponseSchema: z.ZodObject<{
         subTeams: z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"unlimited">]>;
         externalDomainGroups: z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"unlimited">]>;
         boughtDomains: z.ZodLiteral<"unlimited">;
-        publicImmutableVersionWindowDays: z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"unlimited">]>;
         maxFileBytes: z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"unlimited">]>;
         maxVersionFiles: z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"unlimited">]>;
         routingRules: z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"unlimited">]>;
@@ -69,8 +65,6 @@ export declare const PlanPolicyResponseSchema: z.ZodObject<{
     disabledBehaviors: z.ZodOptional<z.ZodArray<z.ZodObject<{
         code: z.ZodEnum<{
             free_external_proxy_disabled: "free_external_proxy_disabled";
-            free_headers_basic_auth_disabled: "free_headers_basic_auth_disabled";
-            immutable_version_requires_login: "immutable_version_requires_login";
             routing_rules_over_plan: "routing_rules_over_plan";
         }>;
         behavior: z.ZodString;
@@ -78,7 +72,6 @@ export declare const PlanPolicyResponseSchema: z.ZodObject<{
             warning: "warning";
             ignored: "ignored";
             platform_page: "platform_page";
-            login_redirect: "login_redirect";
         }>;
     }, z.core.$strip>>>;
 }, z.core.$strip>;

package/dist/contracts/plan-policy.js

@@ -5,9 +5,7 @@ import { planCodeSchema, planLimitValueSchema } from "./features.js";
 // plan does not include them (internal-docs/platform.md "Plans And Limits").
 export const PLAN_DISABLED_BEHAVIOR_CODES = [
     "free_external_proxy_disabled",
-    "free_headers_basic_auth_disabled",
     "routing_rules_over_plan",
-    "immutable_version_requires_login",
 ];
 export const planDisabledBehaviorSchema = z.object({
     code: z
@@ -15,7 +13,7 @@ export const planDisabledBehaviorSchema = z.object({
         .describe("Stable code identifying the disabled behavior."),
     behavior: z.string().describe("What the platform does instead of honoring the behavior."),
     renderedAs: z
-        .enum(["warning", "platform_page", "login_redirect", "ignored"])
+        .enum(["warning", "platform_page", "ignored"])
         .describe("How the disablement surfaces to users."),
 });
 export const PlanPolicyResponseSchema = z.object({
@@ -40,7 +38,6 @@ export const PlanPolicyResponseSchema = z.object({
         boughtDomains: z
             .literal("unlimited")
             .describe("Domains bought through Spacefast never count against external domain limits."),
-        publicImmutableVersionWindowDays: planLimitValueSchema,
         maxFileBytes: planLimitValueSchema,
         maxVersionFiles: planLimitValueSchema.describe("Files per version; plan policy may lower the 100,000-file contract ceiling, never raise it."),
         routingRules: planLimitValueSchema,

package/dist/contracts/platform.d.ts

@@ -28,15 +28,51 @@ export declare const accessLogEntrySchema: z.ZodObject<{
     status: z.ZodNumber;
     bytes: z.ZodNumber;
 }, z.core.$strip>;
+/**
+ * One line a space's own code wrote, from whichever execution tier serves it.
+ *
+ * This is `executionLogEntrySchema` verbatim rather than a platform-shaped
+ * restatement of it: both tiers already emit that shape, and re-declaring it
+ * here would be a second definition to keep in sync with the runtimes that
+ * produce the records.
+ *
+ * Unlike its access-log sibling there is no `ts` alongside `timestamp`. That
+ * duplication is a compatibility alias the access log carries for callers that
+ * predate the rename; runtime logs have never been served to anyone, so there
+ * is no caller to keep and no reason to inherit the wart.
+ */
 export declare const runtimeLogEntrySchema: z.ZodObject<{
-    ts: z.ZodString;
+    id: z.ZodString;
     timestamp: z.ZodString;
-    level: z.ZodString;
-    code: z.ZodString;
+    level: z.ZodEnum<{
+        info: "info";
+        error: "error";
+        debug: "debug";
+        warn: "warn";
+    }>;
+    requestId: z.ZodNullable<z.ZodString>;
+    versionId: z.ZodNullable<z.ZodString>;
+    handlerName: z.ZodNullable<z.ZodString>;
     message: z.ZodString;
-    file: z.ZodNullable<z.ZodString>;
-    line: z.ZodNullable<z.ZodString>;
+    metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strict>;
+export type RuntimeLogEntry = z.infer<typeof runtimeLogEntrySchema>;
+/**
+ * Handler logs are filtered, not windowed.
+ *
+ * The access log takes `since`/`until` because the provider indexes by time.
+ * Neither execution tier does: Zero pages a local append-only store by cursor,
+ * and the origin walks day files backwards from newest. Accepting a `since`
+ * here would mean ignoring it, so it is absent — the filters below are the ones
+ * both tiers actually honour.
+ */
+export declare const runtimeLogListQuerySchema: z.ZodObject<{
+    limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    cursor: z.ZodOptional<z.ZodString>;
+    requestId: z.ZodOptional<z.ZodString>;
+    handlerName: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
+export type RuntimeLogListQuery = z.infer<typeof runtimeLogListQuerySchema>;
 export declare const accessLogListResponseSchema: z.ZodObject<{
     data: z.ZodArray<z.ZodObject<{
         ts: z.ZodString;
@@ -72,40 +108,52 @@ export declare const accessLogListResponseSchema: z.ZodObject<{
         retryable: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
     }, z.core.$strip>>>;
 }, z.core.$strip>;
+/**
+ * Paged handler logs.
+ *
+ * The pagination block is deliberately the same `CursorPaginationSchema` the
+ * access log uses — the two kinds sit side by side under one command, and a
+ * caller should not have to learn a second paging idiom to read the other half
+ * of its own space.
+ *
+ * One thing about that cursor is worth stating rather than discovering: **an
+ * empty page does not mean the end.** `hasMore` is true whenever the server
+ * stopped before reaching the oldest retained line, and the origin reader stops
+ * on its own per-page bounds — day count, line count, bytes scanned — which it
+ * can hit while a `requestId` or `handlerName` filter matched nothing in the
+ * stretch it read. Both tiers satisfy the same rule: **`hasMore: false` means
+ * you have seen everything; `hasMore: true` means keep paging, whatever `data`
+ * held.** A client that stops on the first empty page will silently truncate a
+ * filtered search.
+ *
+ * No `warnings` array, unlike the access log. Its one diagnostic is
+ * `log_retention_clamped`, which reports a requested window being cut back to
+ * the plan's retention — and there is no window to clamp here. An empty
+ * diagnostics channel would be a field every caller must handle and no server
+ * ever fills.
+ */
 export declare const runtimeLogListResponseSchema: z.ZodObject<{
     data: z.ZodArray<z.ZodObject<{
-        ts: z.ZodString;
+        id: z.ZodString;
         timestamp: z.ZodString;
-        level: z.ZodString;
-        code: z.ZodString;
+        level: z.ZodEnum<{
+            info: "info";
+            error: "error";
+            debug: "debug";
+            warn: "warn";
+        }>;
+        requestId: z.ZodNullable<z.ZodString>;
+        versionId: z.ZodNullable<z.ZodString>;
+        handlerName: z.ZodNullable<z.ZodString>;
         message: z.ZodString;
-        file: z.ZodNullable<z.ZodString>;
-        line: z.ZodNullable<z.ZodString>;
-    }, z.core.$strip>>;
+        metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strict>>;
     pagination: z.ZodObject<{
         nextCursor: z.ZodNullable<z.ZodString>;
         hasMore: z.ZodBoolean;
     }, z.core.$strip>;
-    warnings: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        code: z.ZodString;
-        severity: z.ZodEnum<{
-            info: "info";
-            error: "error";
-            warning: "warning";
-        }>;
-        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>>>;
 }, z.core.$strip>;
+export type RuntimeLogListResponse = z.infer<typeof runtimeLogListResponseSchema>;
 export declare const analyticsQuerySchema: z.ZodObject<{
     window: z.ZodOptional<z.ZodEnum<{
         custom: "custom";

package/dist/contracts/platform.js

@@ -1,5 +1,6 @@
 import { z } from "zod";
 import { CursorPaginationSchema, baseDiagnosticSchema, cursorListQuerySchema } from "./common.js";
+import { executionLogEntrySchema } from "./execution.js";
 export const domainPurchaseContactSchema = z.object({
     firstName: z.string().trim().min(1).max(80),
     lastName: z.string().trim().min(1).max(80),
@@ -27,14 +28,40 @@ export const accessLogEntrySchema = z.object({
     status: z.number().int(),
     bytes: z.number().int().nonnegative(),
 });
-export const runtimeLogEntrySchema = z.object({
-    ts: z.string().datetime(),
-    timestamp: z.string().datetime(),
-    level: z.string(),
-    code: z.string(),
-    message: z.string(),
-    file: z.string().nullable(),
-    line: z.string().nullable(),
+/**
+ * One line a space's own code wrote, from whichever execution tier serves it.
+ *
+ * This is `executionLogEntrySchema` verbatim rather than a platform-shaped
+ * restatement of it: both tiers already emit that shape, and re-declaring it
+ * here would be a second definition to keep in sync with the runtimes that
+ * produce the records.
+ *
+ * Unlike its access-log sibling there is no `ts` alongside `timestamp`. That
+ * duplication is a compatibility alias the access log carries for callers that
+ * predate the rename; runtime logs have never been served to anyone, so there
+ * is no caller to keep and no reason to inherit the wart.
+ */
+export const runtimeLogEntrySchema = executionLogEntrySchema;
+/**
+ * Handler logs are filtered, not windowed.
+ *
+ * The access log takes `since`/`until` because the provider indexes by time.
+ * Neither execution tier does: Zero pages a local append-only store by cursor,
+ * and the origin walks day files backwards from newest. Accepting a `since`
+ * here would mean ignoring it, so it is absent — the filters below are the ones
+ * both tiers actually honour.
+ */
+export const runtimeLogListQuerySchema = cursorListQuerySchema.extend({
+    requestId: z
+        .string()
+        .min(1)
+        .optional()
+        .describe("Return only lines emitted while serving this request."),
+    handlerName: z
+        .string()
+        .min(1)
+        .optional()
+        .describe("Return only lines from this handler — a Zero mutation or a Functions handler."),
 });
 export const accessLogListResponseSchema = z.object({
     data: z.array(accessLogEntrySchema),
@@ -44,21 +71,41 @@ export const accessLogListResponseSchema = z.object({
         .optional()
         .describe("List-level diagnostics; log_retention_clamped names the effective `since` when the requested window exceeds the plan's log retention."),
 });
+/**
+ * Paged handler logs.
+ *
+ * The pagination block is deliberately the same `CursorPaginationSchema` the
+ * access log uses — the two kinds sit side by side under one command, and a
+ * caller should not have to learn a second paging idiom to read the other half
+ * of its own space.
+ *
+ * One thing about that cursor is worth stating rather than discovering: **an
+ * empty page does not mean the end.** `hasMore` is true whenever the server
+ * stopped before reaching the oldest retained line, and the origin reader stops
+ * on its own per-page bounds — day count, line count, bytes scanned — which it
+ * can hit while a `requestId` or `handlerName` filter matched nothing in the
+ * stretch it read. Both tiers satisfy the same rule: **`hasMore: false` means
+ * you have seen everything; `hasMore: true` means keep paging, whatever `data`
+ * held.** A client that stops on the first empty page will silently truncate a
+ * filtered search.
+ *
+ * No `warnings` array, unlike the access log. Its one diagnostic is
+ * `log_retention_clamped`, which reports a requested window being cut back to
+ * the plan's retention — and there is no window to clamp here. An empty
+ * diagnostics channel would be a field every caller must handle and no server
+ * ever fills.
+ */
 export const runtimeLogListResponseSchema = z.object({
     data: z.array(runtimeLogEntrySchema),
     pagination: CursorPaginationSchema,
-    warnings: z
-        .array(baseDiagnosticSchema)
-        .optional()
-        .describe("List-level diagnostics; log_retention_clamped names the effective `since` when the requested window exceeds the plan's log retention."),
 });
 export const analyticsQuerySchema = z.object({
     window: z
         .enum(["48h", "7d", "30d", "custom"])
         .optional()
-        .describe('Analytics summary window; defaults to "7d". "custom" requires since/until.'),
-    since: z.string().datetime().optional().describe("Custom analytics start."),
-    until: z.string().datetime().optional().describe("Custom analytics end."),
+        .describe('Analytics summary window. Defaults to "7d". "custom" requires since/until.'),
+    since: z.string().datetime().optional().describe("Start of the custom analytics window."),
+    until: z.string().datetime().optional().describe("End of the custom analytics window."),
 });
 // Served by `GET /v1/spaces/{spaceId}/analytics`: traffic summary over the
 // requested window, read from Spacefast's own per-space rollups (ingested on
@@ -66,7 +113,7 @@ export const analyticsQuerySchema = z.object({
 // Counts cover main hostnames only: default, custom-domain, and channel.
 // Immutable version-URL traffic is ingested but never surfaced here.
 export const analyticsResponseSchema = z.object({
-    spaceId: z.string().describe("Space the traffic was aggregated for."),
+    spaceId: z.string().describe("The space id the traffic was aggregated for."),
     window: z.enum(["48h", "7d", "30d", "custom"]).describe("Resolved summary window."),
     since: z.string().describe("Resolved window start (ISO 8601), after retention clamping."),
     until: z.string().describe("Resolved window end (ISO 8601)."),
@@ -74,15 +121,17 @@ export const analyticsResponseSchema = z.object({
     dataAsOf: z
         .string()
         .nullable()
-        .describe("End of the last fully-ingested hour; null while the first ingest is running."),
-    refreshing: z.boolean().describe("Whether an ingest run is active or was just triggered."),
+        .describe("End of the last fully-ingested hour; null until the first ingest starts."),
+    refreshing: z
+        .boolean()
+        .describe("Whether an ingest run is active or the server just triggered one."),
     views: z
         .number()
         .describe("Successful non-crawler requests (status < 400, assets included) summed across main hostnames over the window."),
     visitors: z
         .number()
         .nullable()
-        .describe("Unique-visitor estimate. Currently always null: per-hostname unique-visitor data is not yet available from the hosting provider."),
+        .describe("Unique-visitor estimate. Always null because per-hostname unique-visitor data is not yet available from the hosting provider."),
     bandwidthBytes: z.number().describe("Total response bytes in the window."),
     visitorsByHost: z
         .array(z.object({
@@ -93,7 +142,7 @@ export const analyticsResponseSchema = z.object({
             views: z.number(),
         })),
     }))
-        .describe("Per-hostname daily visitor estimates. Currently always empty: per-hostname unique-visitor data is not yet available from the hosting provider."),
+        .describe("Per-hostname daily visitor estimates. Always empty because per-hostname unique-visitor data is not yet available from the hosting provider."),
     topPaths: z
         .array(z.object({ path: z.string(), views: z.number() }))
         .describe("Most-viewed paths, capped at 10."),

package/dist/contracts/problem-document.d.ts

@@ -0,0 +1,14 @@
+export interface ProblemDocument {
+    code: string | undefined;
+    detail: string | undefined;
+    type: string | undefined;
+    title: string | undefined;
+    pointer: string | undefined;
+    /** Raw, unnarrowed: each caller decides what shape it accepts. */
+    details: unknown;
+    suggestions: string[];
+    next: string[];
+    requestId: string | undefined;
+}
+/** Returns undefined when the payload cannot be a problem document at all. */
+export declare function parseProblemDocument(payload: unknown): ProblemDocument | undefined;

package/dist/contracts/problem-document.js

@@ -0,0 +1,35 @@
+// Reader for the RFC 9457 problem document every 4xx/5xx response carries, so the
+// client surfaces (CLI, MCP, SDK) share one definition of which members exist and
+// which values are trusted. Callers keep their own entry guards, message fallbacks
+// and public field names — this only extracts the wire members.
+/** Returns undefined when the payload cannot be a problem document at all. */
+export function parseProblemDocument(payload) {
+    if (!payload || typeof payload !== "object" || Array.isArray(payload)) {
+        return undefined;
+    }
+    const problem = payload;
+    if (!("code" in problem) && !("detail" in problem)) {
+        return undefined;
+    }
+    const stringField = (name) => {
+        const value = problem[name];
+        return typeof value === "string" ? value : undefined;
+    };
+    const stringArray = (name) => {
+        const value = problem[name];
+        return Array.isArray(value)
+            ? value.filter((entry) => typeof entry === "string")
+            : [];
+    };
+    return {
+        code: stringField("code"),
+        detail: stringField("detail"),
+        type: stringField("type"),
+        title: stringField("title"),
+        pointer: stringField("pointer"),
+        details: problem.details,
+        suggestions: stringArray("suggestions"),
+        next: stringArray("next"),
+        requestId: stringField("requestId"),
+    };
+}

package/dist/contracts/push-new.d.ts

@@ -50,6 +50,19 @@ export declare const PushNewSessionSchema: z.ZodObject<{
     reusedVersionId: z.ZodNullable<z.ZodString>;
     webhookDeliveryId: z.ZodNullable<z.ZodString>;
     liveUrl: z.ZodString;
+    open: z.ZodNullable<z.ZodUnion<readonly [z.ZodObject<{
+        url: z.ZodString;
+        expiresAt: z.ZodNullable<z.ZodString>;
+        kind: z.ZodLiteral<"link">;
+    }, z.core.$strip>, z.ZodObject<{
+        url: z.ZodString;
+        expiresAt: z.ZodString;
+        kind: z.ZodEnum<{
+            management: "management";
+            person: "person";
+            claim_preview: "claim_preview";
+        }>;
+    }, z.core.$strip>]>>;
     sessionUrl: z.ZodString;
     logsUrl: z.ZodNullable<z.ZodString>;
     claimUrl: z.ZodString;
@@ -95,6 +108,19 @@ export declare const PushNewCreateSessionResponseSchema: z.ZodObject<{
     reusedVersionId: z.ZodNullable<z.ZodString>;
     webhookDeliveryId: z.ZodNullable<z.ZodString>;
     liveUrl: z.ZodString;
+    open: z.ZodNullable<z.ZodUnion<readonly [z.ZodObject<{
+        url: z.ZodString;
+        expiresAt: z.ZodNullable<z.ZodString>;
+        kind: z.ZodLiteral<"link">;
+    }, z.core.$strip>, z.ZodObject<{
+        url: z.ZodString;
+        expiresAt: z.ZodString;
+        kind: z.ZodEnum<{
+            management: "management";
+            person: "person";
+            claim_preview: "claim_preview";
+        }>;
+    }, z.core.$strip>]>>;
     sessionUrl: z.ZodString;
     logsUrl: z.ZodNullable<z.ZodString>;
     claimUrl: z.ZodString;
@@ -108,6 +134,19 @@ export declare const PushNewCreateSessionResponseSchema: z.ZodObject<{
 }, z.core.$strip>;
 export declare const PushNewStatusResponseSchema: z.ZodObject<{
     id: z.ZodString;
+    open: z.ZodNullable<z.ZodUnion<readonly [z.ZodObject<{
+        url: z.ZodString;
+        expiresAt: z.ZodNullable<z.ZodString>;
+        kind: z.ZodLiteral<"link">;
+    }, z.core.$strip>, z.ZodObject<{
+        url: z.ZodString;
+        expiresAt: z.ZodString;
+        kind: z.ZodEnum<{
+            management: "management";
+            person: "person";
+            claim_preview: "claim_preview";
+        }>;
+    }, z.core.$strip>]>>;
     status: z.ZodEnum<{
         live: "live";
         failed: "failed";
@@ -121,10 +160,10 @@ export declare const PushNewStatusResponseSchema: z.ZodObject<{
     createdAt: z.ZodString;
     spaceId: z.ZodString;
     updatedAt: z.ZodString;
-    ref: z.ZodNullable<z.ZodString>;
+    branch: z.ZodString;
     versionId: z.ZodNullable<z.ZodString>;
+    ref: z.ZodNullable<z.ZodString>;
     spaceSlug: z.ZodString;
-    branch: z.ZodString;
     commitSha: z.ZodNullable<z.ZodString>;
     repositoryFullName: z.ZodNullable<z.ZodString>;
     slug: z.ZodString;

package/dist/contracts/push-new.js

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import { privateOpenSchema } from "./access.js";
 export const pushNewSessionStatusSchema = z.enum([
     "waiting_for_push",
     "waiting_for_upload",
@@ -31,6 +32,9 @@ export const PushNewSessionSchema = z.object({
     reusedVersionId: z.string().nullable(),
     webhookDeliveryId: z.string().nullable(),
     liveUrl: z.string().url(),
+    open: privateOpenSchema
+        .nullable()
+        .describe("Reusable Open link for the private space at live `/`. A null expiry means it remains valid until revoked."),
     sessionUrl: z.string().url(),
     logsUrl: z.string().url().nullable(),
     claimUrl: z.string().url(),

package/dist/contracts/quotas.d.ts

@@ -14,5 +14,4 @@ export declare const ANONYMOUS_PUBLISH_CAPS: {
     readonly maxInlineBodyBytes: number;
     readonly maxFilesPerVersion: 1000;
     readonly maxPublishesPerIpPerHour: 20;
-    readonly maxLifetimeViews: 100;
 };

package/dist/contracts/quotas.js

@@ -36,9 +36,4 @@ export const ANONYMOUS_PUBLISH_CAPS = {
     maxFilesPerVersion: 1000,
     // Anonymous publish/space-create attempts per IP per hour.
     maxPublishesPerIpPerHour: WORST_CASE_QUOTAS.maxPublishesPerIpPerHour,
-    // Views (non-crawler, status<400 requests) an unclaimed space may serve over
-    // its whole claim window before it goes dark behind the claim-nudge
-    // tombstone. Enforced by the periodic visit-quota sweep, so it is
-    // deliberately approximate — claiming the space lifts it entirely.
-    maxLifetimeViews: 100,
 };

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

@@ -124,8 +124,8 @@ export declare const repositoryImportRemoteSchema: z.ZodObject<{
         bitbucket: "bitbucket";
         generic: "generic";
     }>>;
-    repositoryFullName: z.ZodString;
     credential: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    repositoryFullName: z.ZodString;
     repositoryId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     repositoryName: z.ZodOptional<z.ZodString>;
     defaultBranch: z.ZodDefault<z.ZodString>;