@spacefast/common 0.0.12 → 0.0.13

package/dist/contracts/ids.d.ts

@@ -27,10 +27,12 @@ export declare const ID_PREFIXES: {
     readonly tgp: "TagPreviewSession";
     readonly bhk: "BuildHook";
     readonly lnk: "ShareLink";
-    readonly sin: "SpaceInvite";
+    readonly per: "SpacePerson";
     readonly arq: "AccessRequest";
-    readonly stk: "ServiceToken";
-    readonly acn: "AccessConnection";
+    readonly grt: "SpaceGrant";
+    readonly acn: "IdentityConnection";
+    readonly pwd: "SpacePasswordCredential";
+    readonly mch: "SpaceMachineCredential";
     readonly mnt: "StaticMount";
 };
 export type IdPrefix = keyof typeof ID_PREFIXES;

package/dist/contracts/ids.js

@@ -35,10 +35,12 @@ export const ID_PREFIXES = {
     // Reserved for the deferred build-hook surface; never minted yet.
     bhk: "BuildHook",
     lnk: "ShareLink",
-    sin: "SpaceInvite",
+    per: "SpacePerson",
     arq: "AccessRequest",
-    stk: "ServiceToken",
-    acn: "AccessConnection",
+    grt: "SpaceGrant",
+    acn: "IdentityConnection",
+    pwd: "SpacePasswordCredential",
+    mch: "SpaceMachineCredential",
     mnt: "StaticMount",
 };
 /** Validate an id belonging to one registered public resource family. */

package/dist/contracts/mcp.d.ts

@@ -104,8 +104,8 @@ export declare const hostedMcpExecutionArtifactSchema: z.ZodObject<{
         resource: "resource";
         warning: "warning";
         summary: "summary";
-        result: "result";
         log: "log";
+        result: "result";
     }>;
     name: z.ZodString;
     mimeType: z.ZodNullable<z.ZodString>;
@@ -154,8 +154,8 @@ export declare const hostedMcpExecutionRunSchema: z.ZodObject<{
             resource: "resource";
             warning: "warning";
             summary: "summary";
-            result: "result";
             log: "log";
+            result: "result";
         }>;
         name: z.ZodString;
         mimeType: z.ZodNullable<z.ZodString>;
@@ -380,8 +380,8 @@ export declare const hostedMcpDashboardSchema: z.ZodObject<{
                 resource: "resource";
                 warning: "warning";
                 summary: "summary";
-                result: "result";
                 log: "log";
+                result: "result";
             }>;
             name: z.ZodString;
             mimeType: z.ZodNullable<z.ZodString>;
@@ -545,8 +545,8 @@ export declare const hostedMcpDashboardResponseSchema: z.ZodObject<{
                     resource: "resource";
                     warning: "warning";
                     summary: "summary";
-                    result: "result";
                     log: "log";
+                    result: "result";
                 }>;
                 name: z.ZodString;
                 mimeType: z.ZodNullable<z.ZodString>;
@@ -710,8 +710,8 @@ export declare const hostedMcpExecutionRunsResponseSchema: z.ZodObject<{
                     resource: "resource";
                     warning: "warning";
                     summary: "summary";
-                    result: "result";
                     log: "log";
+                    result: "result";
                 }>;
                 name: z.ZodString;
                 mimeType: z.ZodNullable<z.ZodString>;
@@ -764,8 +764,8 @@ export declare const hostedMcpExecutionRunResponseSchema: z.ZodObject<{
                 resource: "resource";
                 warning: "warning";
                 summary: "summary";
-                result: "result";
                 log: "log";
+                result: "result";
             }>;
             name: z.ZodString;
             mimeType: z.ZodNullable<z.ZodString>;

package/dist/contracts/oauth-resources.d.ts

@@ -3,22 +3,22 @@ export declare const OAUTH_AUTHORIZATION_SERVER_PATH: "/v1/auth";
  * mcp origin (`https://mcp.<domain>`), so it has no path entry here. */
 export declare const OAUTH_API_RESOURCE_PATH: "/v1";
 export type OAuthResourceKey = "api" | "mcp";
-export declare const OAUTH_API_RESOURCE_SCOPES: readonly ["teams:read", "teams:create", "spaces:read", "spaces:write", "publish:write", "domains:read", "domains:write"];
+export declare const OAUTH_API_RESOURCE_SCOPES: readonly ["teams:read", "teams:create", "spaces:read", "spaces:write", "spaces:rename", "publish:write", "domains:read", "domains:write"];
 export declare const OAUTH_MCP_TOOL_SCOPE: "mcp:tools";
-export declare const OAUTH_MCP_RESOURCE_SCOPES: readonly ["mcp:tools", "teams:read", "teams:create", "spaces:read", "spaces:write", "publish:write", "domains:read", "domains:write"];
-export declare const OAUTH_PROVIDER_SCOPES: readonly ["openid", "profile", "email", "offline_access", "teams:read", "teams:create", "spaces:read", "spaces:write", "publish:write", "domains:read", "domains:write", "mcp:tools"];
+export declare const OAUTH_MCP_RESOURCE_SCOPES: readonly ["mcp:tools", "teams:read", "teams:create", "spaces:read", "spaces:write", "spaces:rename", "publish:write", "domains:read", "domains:write"];
+export declare const OAUTH_PROVIDER_SCOPES: readonly ["openid", "profile", "email", "offline_access", "teams:read", "teams:create", "spaces:read", "spaces:write", "spaces:rename", "publish:write", "domains:read", "domains:write", "mcp:tools"];
 export declare const OAUTH_RESOURCE_DEFINITIONS: {
     readonly api: {
         readonly key: "api";
         readonly name: "Spacefast API";
         readonly accessTokenTtlSeconds: number;
-        readonly allowedScopes: readonly ["teams:read", "teams:create", "spaces:read", "spaces:write", "publish:write", "domains:read", "domains:write"];
+        readonly allowedScopes: readonly ["teams:read", "teams:create", "spaces:read", "spaces:write", "spaces:rename", "publish:write", "domains:read", "domains:write"];
     };
     readonly mcp: {
         readonly key: "mcp";
         readonly name: "Spacefast MCP";
         readonly accessTokenTtlSeconds: number;
-        readonly allowedScopes: readonly ["mcp:tools", "teams:read", "teams:create", "spaces:read", "spaces:write", "publish:write", "domains:read", "domains:write"];
+        readonly allowedScopes: readonly ["mcp:tools", "teams:read", "teams:create", "spaces:read", "spaces:write", "spaces:rename", "publish:write", "domains:read", "domains:write"];
     };
 };
 /** Resource identifier for the public API: `https://api.<domain>/v1`. */

package/dist/contracts/oauth-resources.js

@@ -7,6 +7,7 @@ export const OAUTH_API_RESOURCE_SCOPES = [
     "teams:create",
     "spaces:read",
     "spaces:write",
+    "spaces:rename",
     "publish:write",
     "domains:read",
     "domains:write",

package/dist/contracts/operations.d.ts

@@ -80,8 +80,8 @@ export declare const UserOperationSchema: z.ZodObject<{
     }>>;
     integrationRelease: z.ZodOptional<z.ZodObject<{
         environment: z.ZodEnum<{
-            production: "production";
             preview: "preview";
+            production: "production";
             development: "development";
         }>;
     }, z.core.$strip>>;
@@ -178,8 +178,8 @@ export declare const operationListResponseSchema: z.ZodObject<{
         }>>;
         integrationRelease: z.ZodOptional<z.ZodObject<{
             environment: z.ZodEnum<{
-                production: "production";
                 preview: "preview";
+                production: "production";
                 development: "development";
             }>;
         }, z.core.$strip>>;

package/dist/contracts/pages.d.ts

@@ -1,37 +1,31 @@
 import { z } from "zod";
-export declare const SITE_PAGE_IDS: readonly ["404", "password", "denied", "login", "index", "preview"];
+export declare const SITE_PAGE_IDS: readonly ["404", "denied", "index", "preview"];
 export declare const sitePageIdSchema: z.ZodEnum<{
-    login: "login";
-    password: "password";
     denied: "denied";
     index: "index";
     preview: "preview";
     404: "404";
 }>;
 export type SitePageId = z.infer<typeof sitePageIdSchema>;
-export declare const ROUTE_PAGE_IDS: readonly ["404", "password", "denied", "login"];
+export declare const ROUTE_PAGE_IDS: readonly ["404", "denied"];
 export declare const routePageIdSchema: z.ZodEnum<{
-    login: "login";
-    password: "password";
     denied: "denied";
     404: "404";
 }>;
 export type RoutePageId = z.infer<typeof routePageIdSchema>;
-export declare const CUSTOM_PAGE_IDS: readonly ["404", "password", "denied", "index", "preview"];
+export declare const CUSTOM_PAGE_IDS: readonly ["404", "denied", "index", "preview"];
 export declare const customPageIdSchema: z.ZodEnum<{
-    password: "password";
     denied: "denied";
     index: "index";
     preview: "preview";
     404: "404";
 }>;
 export type CustomPageId = z.infer<typeof customPageIdSchema>;
-export declare const PLATFORM_PAGE_IDS: readonly ["undeployed", "suspended", "legal", "visit-cap", "gone", "runtime-error", "rate-limited", "tier-unavailable", "proxy-error", "method-not-allowed", "content-too-large"];
+export declare const PLATFORM_PAGE_IDS: readonly ["undeployed", "suspended", "legal", "gone", "runtime-error", "rate-limited", "tier-unavailable", "proxy-error", "method-not-allowed", "content-too-large"];
 export declare const platformPageIdSchema: z.ZodEnum<{
     legal: "legal";
     suspended: "suspended";
     undeployed: "undeployed";
-    "visit-cap": "visit-cap";
     gone: "gone";
     "runtime-error": "runtime-error";
     "rate-limited": "rate-limited";
@@ -41,12 +35,12 @@ export declare const platformPageIdSchema: z.ZodEnum<{
     "content-too-large": "content-too-large";
 }>;
 export type PlatformPageId = z.infer<typeof platformPageIdSchema>;
-export declare const PAGE_ELEMENTS: readonly ["sf-content", "sf-password-form", "sf-login", "sf-denial-context", "sf-page-path", "sf-page-title", "sf-page-summary", "sf-spacefast-branding", "sf-files", "sf-file", "sf-logo", "sf-name"];
+export declare const PAGE_ELEMENTS: readonly ["sf-content", "sf-denial-context", "sf-page-path", "sf-page-title", "sf-page-summary", "sf-spacefast-branding", "sf-files", "sf-file", "sf-logo", "sf-name"];
 export type PageElement = (typeof PAGE_ELEMENTS)[number];
 export type PageDefinition = {
     id: SitePageId;
     status: 200 | 401 | 403 | 404;
-    cacheControl: "public, max-age=0, s-maxage=60, must-revalidate" | "private, no-store";
+    cacheControl: "public, max-age=0, s-maxage=600, stale-while-revalidate=60" | "private, no-store";
     noindex: boolean;
     customTemplate: boolean;
 };
@@ -58,8 +52,6 @@ export declare const pageArtifactKeySchema: z.ZodString;
 export declare const runtimePagesSchema: z.ZodObject<{
     routes: z.ZodRecord<z.ZodString, z.ZodObject<{
         pages: z.ZodOptional<z.ZodRecord<z.ZodEnum<{
-            login: "login";
-            password: "password";
             denied: "denied";
             404: "404";
         }>, z.ZodString>>;

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", "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"];
 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", "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,8 +20,6 @@ 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-page-path",
     "sf-page-title",
@@ -37,42 +34,28 @@ 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,
-    },
-    login: {
-        id: "login",
-        status: 401,
-        cacheControl: "private, no-store",
-        noindex: true,
         customTemplate: false,
     },
     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,13 +71,33 @@ 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

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

@@ -50,6 +50,14 @@ export declare const PushNewSessionSchema: z.ZodObject<{
     reusedVersionId: z.ZodNullable<z.ZodString>;
     webhookDeliveryId: z.ZodNullable<z.ZodString>;
     liveUrl: z.ZodString;
+    open: z.ZodNullable<z.ZodObject<{
+        url: z.ZodString;
+        expiresAt: z.ZodString;
+        kind: z.ZodEnum<{
+            management: "management";
+            claim_preview: "claim_preview";
+        }>;
+    }, z.core.$strip>>;
     sessionUrl: z.ZodString;
     logsUrl: z.ZodNullable<z.ZodString>;
     claimUrl: z.ZodString;
@@ -95,6 +103,14 @@ export declare const PushNewCreateSessionResponseSchema: z.ZodObject<{
     reusedVersionId: z.ZodNullable<z.ZodString>;
     webhookDeliveryId: z.ZodNullable<z.ZodString>;
     liveUrl: z.ZodString;
+    open: z.ZodNullable<z.ZodObject<{
+        url: z.ZodString;
+        expiresAt: z.ZodString;
+        kind: z.ZodEnum<{
+            management: "management";
+            claim_preview: "claim_preview";
+        }>;
+    }, z.core.$strip>>;
     sessionUrl: z.ZodString;
     logsUrl: z.ZodNullable<z.ZodString>;
     claimUrl: z.ZodString;
@@ -108,6 +124,14 @@ export declare const PushNewCreateSessionResponseSchema: z.ZodObject<{
 }, z.core.$strip>;
 export declare const PushNewStatusResponseSchema: z.ZodObject<{
     id: z.ZodString;
+    open: z.ZodNullable<z.ZodObject<{
+        url: z.ZodString;
+        expiresAt: z.ZodString;
+        kind: z.ZodEnum<{
+            management: "management";
+            claim_preview: "claim_preview";
+        }>;
+    }, z.core.$strip>>;
     status: z.ZodEnum<{
         live: "live";
         failed: "failed";
@@ -121,10 +145,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;