@spacefast/common 0.0.24 → 0.0.26

package/dist/docs/skills.d.ts

@@ -23,13 +23,13 @@ export interface SpacefastSkillDefinition {
 export declare const SPACEFAST_SKILLS: readonly [{
     readonly name: "create-and-publish-site";
     readonly title: "Create and publish a polished website";
-    readonly description: "Turn a brief into a responsive static website, review the result, publish it to Spacefast, and verify the live version.";
+    readonly description: "Turn a brief into a responsive website, review the result, publish it to Spacefast, and verify the live version.";
     readonly whenToUse: "Use when the user wants an agent to design, build, improve, or launch a new website rather than only upload an existing build.";
     readonly keywords: readonly ["create", "website", "design", "build", "responsive", "launch", "publish"];
     readonly runtimes: readonly ["local", "hosted"];
     readonly tools: readonly ["publish", "execute"];
     readonly docs: readonly ["quickstart", "publishing"];
-    readonly instructions: readonly ["Clarify the audience, goal, required content, brand constraints, and desired call to action. If the visual direction is open, propose two or three distinct directions and choose one with the user.", "Inspect the existing workspace before editing. Reuse its framework, package manager, components, assets, and build conventions when they are sound.", "Build a focused, accessible static experience with a clear hierarchy, real content, responsive layouts, useful interaction states, and no placeholder copy. Keep the main path simple and put secondary detail behind progressive disclosure.", "Run the real build and inspect the result at mobile and desktop widths. Fix overflow, illegible contrast, broken links, missing assets, keyboard traps, and avoidable layout shift.", "Review the workspace diff and summarize material design or content judgments before publishing. Never include API keys, claim credentials, upload credentials, or local auth state in the artifact.", "Publish the built output with `publish`. Present Open as the reusable access link and Claim as the one-time ownership link. Treat live and immutable-version URLs as receipt metadata, not extra actions."];
+    readonly instructions: readonly ["Clarify the audience, goal, required content, brand constraints, and desired call to action. If the visual direction is open, propose two or three distinct directions and choose one with the user.", "Inspect the existing workspace before editing. Reuse its framework, package manager, components, assets, and build conventions when they are sound.", "Build a focused, accessible experience with a clear hierarchy, real content, responsive layouts, useful interaction states, and no placeholder copy. Keep the main path simple and put secondary detail behind progressive disclosure.", "Run the real build and inspect the result at mobile and desktop widths. Fix overflow, illegible contrast, broken links, missing assets, keyboard traps, and avoidable layout shift.", "Review the workspace diff and summarize material design or content judgments before publishing. Never include API keys, claim credentials, upload credentials, or local auth state in the artifact.", "Publish the built output with `publish`. Present Open as the reusable access link and Claim as the one-time ownership link. Treat live and immutable-version URLs as receipt metadata, not extra actions."];
     readonly verification: readonly ["Call `status` after publishing and confirm the intended version is live; use `diagnose` if serving is stalled or failed.", "Open the live URL and verify the primary page, navigation, assets, responsive layout, and main call to action before claiming success."];
     readonly runtimeNotes: {
         readonly local: "On-Device can work directly inside the configured local workspace root and publish a local build path.";
@@ -44,13 +44,13 @@ export declare const SPACEFAST_SKILLS: readonly [{
 }, {
     readonly name: "publish-and-verify";
     readonly title: "Publish and verify";
-    readonly description: "Publish an existing static build, confirm the new version is actually live, and return the useful URLs without leaking credentials.";
+    readonly description: "Publish an existing build, confirm the new version is actually live, and return the useful URLs without leaking credentials.";
     readonly whenToUse: "Use when the artifact already exists and the user wants it published or updated.";
     readonly keywords: readonly ["publish", "deploy", "live", "verify", "version", "claim"];
     readonly runtimes: readonly ["local", "hosted"];
     readonly tools: readonly ["publish", "status", "diagnose"];
     readonly docs: readonly ["publishing", "workflow/publish-receipt", "workflow/secret-handling"];
-    readonly instructions: readonly ["Identify the actual publish root or build output. Run the real build first when the source tree is not itself the static artifact.", "Publish with `publish`. For an anonymous On-Device publish, keep the claim credential in local custody and return only the claim URL and expiry; never expose or ask the user to paste the raw token.", "Report the bare Live URL, private Access URL when present, immutable Version URL when present, anonymous Claim URL and expiry when present, plus actionable diagnostics."];
+    readonly instructions: readonly ["Identify the actual publish root or build output. Run the real build first when the source tree is not itself the artifact to publish.", "Publish with `publish`. For an anonymous On-Device publish, keep the claim credential in local custody and return only the claim URL and expiry; never expose or ask the user to paste the raw token.", "Report the bare Live URL, private Access URL when present, immutable Version URL when present, anonymous Claim URL and expiry when present, plus actionable diagnostics."];
     readonly verification: readonly ["Call `status` and confirm the intended version is live. Use `diagnose` for a failed or stalled publish.", "Open the live URL and verify representative content and assets rather than treating a successful upload or health check as serving proof."];
     readonly runtimeNotes: {
         readonly local: "Publish a bounded local path; locally custodied claim credentials are reused automatically.";
@@ -196,13 +196,13 @@ export declare const SPACEFAST_SKILLS: readonly [{
 export declare const SPACEFAST_PROMPT_SKILLS: ({
     readonly name: "create-and-publish-site";
     readonly title: "Create and publish a polished website";
-    readonly description: "Turn a brief into a responsive static website, review the result, publish it to Spacefast, and verify the live version.";
+    readonly description: "Turn a brief into a responsive website, review the result, publish it to Spacefast, and verify the live version.";
     readonly whenToUse: "Use when the user wants an agent to design, build, improve, or launch a new website rather than only upload an existing build.";
     readonly keywords: readonly ["create", "website", "design", "build", "responsive", "launch", "publish"];
     readonly runtimes: readonly ["local", "hosted"];
     readonly tools: readonly ["publish", "execute"];
     readonly docs: readonly ["quickstart", "publishing"];
-    readonly instructions: readonly ["Clarify the audience, goal, required content, brand constraints, and desired call to action. If the visual direction is open, propose two or three distinct directions and choose one with the user.", "Inspect the existing workspace before editing. Reuse its framework, package manager, components, assets, and build conventions when they are sound.", "Build a focused, accessible static experience with a clear hierarchy, real content, responsive layouts, useful interaction states, and no placeholder copy. Keep the main path simple and put secondary detail behind progressive disclosure.", "Run the real build and inspect the result at mobile and desktop widths. Fix overflow, illegible contrast, broken links, missing assets, keyboard traps, and avoidable layout shift.", "Review the workspace diff and summarize material design or content judgments before publishing. Never include API keys, claim credentials, upload credentials, or local auth state in the artifact.", "Publish the built output with `publish`. Present Open as the reusable access link and Claim as the one-time ownership link. Treat live and immutable-version URLs as receipt metadata, not extra actions."];
+    readonly instructions: readonly ["Clarify the audience, goal, required content, brand constraints, and desired call to action. If the visual direction is open, propose two or three distinct directions and choose one with the user.", "Inspect the existing workspace before editing. Reuse its framework, package manager, components, assets, and build conventions when they are sound.", "Build a focused, accessible experience with a clear hierarchy, real content, responsive layouts, useful interaction states, and no placeholder copy. Keep the main path simple and put secondary detail behind progressive disclosure.", "Run the real build and inspect the result at mobile and desktop widths. Fix overflow, illegible contrast, broken links, missing assets, keyboard traps, and avoidable layout shift.", "Review the workspace diff and summarize material design or content judgments before publishing. Never include API keys, claim credentials, upload credentials, or local auth state in the artifact.", "Publish the built output with `publish`. Present Open as the reusable access link and Claim as the one-time ownership link. Treat live and immutable-version URLs as receipt metadata, not extra actions."];
     readonly verification: readonly ["Call `status` after publishing and confirm the intended version is live; use `diagnose` if serving is stalled or failed.", "Open the live URL and verify the primary page, navigation, assets, responsive layout, and main call to action before claiming success."];
     readonly runtimeNotes: {
         readonly local: "On-Device can work directly inside the configured local workspace root and publish a local build path.";
@@ -217,13 +217,13 @@ export declare const SPACEFAST_PROMPT_SKILLS: ({
 } | {
     readonly name: "publish-and-verify";
     readonly title: "Publish and verify";
-    readonly description: "Publish an existing static build, confirm the new version is actually live, and return the useful URLs without leaking credentials.";
+    readonly description: "Publish an existing build, confirm the new version is actually live, and return the useful URLs without leaking credentials.";
     readonly whenToUse: "Use when the artifact already exists and the user wants it published or updated.";
     readonly keywords: readonly ["publish", "deploy", "live", "verify", "version", "claim"];
     readonly runtimes: readonly ["local", "hosted"];
     readonly tools: readonly ["publish", "status", "diagnose"];
     readonly docs: readonly ["publishing", "workflow/publish-receipt", "workflow/secret-handling"];
-    readonly instructions: readonly ["Identify the actual publish root or build output. Run the real build first when the source tree is not itself the static artifact.", "Publish with `publish`. For an anonymous On-Device publish, keep the claim credential in local custody and return only the claim URL and expiry; never expose or ask the user to paste the raw token.", "Report the bare Live URL, private Access URL when present, immutable Version URL when present, anonymous Claim URL and expiry when present, plus actionable diagnostics."];
+    readonly instructions: readonly ["Identify the actual publish root or build output. Run the real build first when the source tree is not itself the artifact to publish.", "Publish with `publish`. For an anonymous On-Device publish, keep the claim credential in local custody and return only the claim URL and expiry; never expose or ask the user to paste the raw token.", "Report the bare Live URL, private Access URL when present, immutable Version URL when present, anonymous Claim URL and expiry when present, plus actionable diagnostics."];
     readonly verification: readonly ["Call `status` and confirm the intended version is live. Use `diagnose` for a failed or stalled publish.", "Open the live URL and verify representative content and assets rather than treating a successful upload or health check as serving proof."];
     readonly runtimeNotes: {
         readonly local: "Publish a bounded local path; locally custodied claim credentials are reused automatically.";
@@ -369,13 +369,13 @@ export declare const SPACEFAST_PROMPT_SKILLS: ({
 export declare const SPACEFAST_RECIPE_SKILLS: (({
     readonly name: "create-and-publish-site";
     readonly title: "Create and publish a polished website";
-    readonly description: "Turn a brief into a responsive static website, review the result, publish it to Spacefast, and verify the live version.";
+    readonly description: "Turn a brief into a responsive website, review the result, publish it to Spacefast, and verify the live version.";
     readonly whenToUse: "Use when the user wants an agent to design, build, improve, or launch a new website rather than only upload an existing build.";
     readonly keywords: readonly ["create", "website", "design", "build", "responsive", "launch", "publish"];
     readonly runtimes: readonly ["local", "hosted"];
     readonly tools: readonly ["publish", "execute"];
     readonly docs: readonly ["quickstart", "publishing"];
-    readonly instructions: readonly ["Clarify the audience, goal, required content, brand constraints, and desired call to action. If the visual direction is open, propose two or three distinct directions and choose one with the user.", "Inspect the existing workspace before editing. Reuse its framework, package manager, components, assets, and build conventions when they are sound.", "Build a focused, accessible static experience with a clear hierarchy, real content, responsive layouts, useful interaction states, and no placeholder copy. Keep the main path simple and put secondary detail behind progressive disclosure.", "Run the real build and inspect the result at mobile and desktop widths. Fix overflow, illegible contrast, broken links, missing assets, keyboard traps, and avoidable layout shift.", "Review the workspace diff and summarize material design or content judgments before publishing. Never include API keys, claim credentials, upload credentials, or local auth state in the artifact.", "Publish the built output with `publish`. Present Open as the reusable access link and Claim as the one-time ownership link. Treat live and immutable-version URLs as receipt metadata, not extra actions."];
+    readonly instructions: readonly ["Clarify the audience, goal, required content, brand constraints, and desired call to action. If the visual direction is open, propose two or three distinct directions and choose one with the user.", "Inspect the existing workspace before editing. Reuse its framework, package manager, components, assets, and build conventions when they are sound.", "Build a focused, accessible experience with a clear hierarchy, real content, responsive layouts, useful interaction states, and no placeholder copy. Keep the main path simple and put secondary detail behind progressive disclosure.", "Run the real build and inspect the result at mobile and desktop widths. Fix overflow, illegible contrast, broken links, missing assets, keyboard traps, and avoidable layout shift.", "Review the workspace diff and summarize material design or content judgments before publishing. Never include API keys, claim credentials, upload credentials, or local auth state in the artifact.", "Publish the built output with `publish`. Present Open as the reusable access link and Claim as the one-time ownership link. Treat live and immutable-version URLs as receipt metadata, not extra actions."];
     readonly verification: readonly ["Call `status` after publishing and confirm the intended version is live; use `diagnose` if serving is stalled or failed.", "Open the live URL and verify the primary page, navigation, assets, responsive layout, and main call to action before claiming success."];
     readonly runtimeNotes: {
         readonly local: "On-Device can work directly inside the configured local workspace root and publish a local build path.";
@@ -390,13 +390,13 @@ export declare const SPACEFAST_RECIPE_SKILLS: (({
 } | {
     readonly name: "publish-and-verify";
     readonly title: "Publish and verify";
-    readonly description: "Publish an existing static build, confirm the new version is actually live, and return the useful URLs without leaking credentials.";
+    readonly description: "Publish an existing build, confirm the new version is actually live, and return the useful URLs without leaking credentials.";
     readonly whenToUse: "Use when the artifact already exists and the user wants it published or updated.";
     readonly keywords: readonly ["publish", "deploy", "live", "verify", "version", "claim"];
     readonly runtimes: readonly ["local", "hosted"];
     readonly tools: readonly ["publish", "status", "diagnose"];
     readonly docs: readonly ["publishing", "workflow/publish-receipt", "workflow/secret-handling"];
-    readonly instructions: readonly ["Identify the actual publish root or build output. Run the real build first when the source tree is not itself the static artifact.", "Publish with `publish`. For an anonymous On-Device publish, keep the claim credential in local custody and return only the claim URL and expiry; never expose or ask the user to paste the raw token.", "Report the bare Live URL, private Access URL when present, immutable Version URL when present, anonymous Claim URL and expiry when present, plus actionable diagnostics."];
+    readonly instructions: readonly ["Identify the actual publish root or build output. Run the real build first when the source tree is not itself the artifact to publish.", "Publish with `publish`. For an anonymous On-Device publish, keep the claim credential in local custody and return only the claim URL and expiry; never expose or ask the user to paste the raw token.", "Report the bare Live URL, private Access URL when present, immutable Version URL when present, anonymous Claim URL and expiry when present, plus actionable diagnostics."];
     readonly verification: readonly ["Call `status` and confirm the intended version is live. Use `diagnose` for a failed or stalled publish.", "Open the live URL and verify representative content and assets rather than treating a successful upload or health check as serving proof."];
     readonly runtimeNotes: {
         readonly local: "Publish a bounded local path; locally custodied claim credentials are reused automatically.";

package/dist/docs/skills.js

@@ -5,7 +5,7 @@ export const SPACEFAST_SKILLS = [
     {
         name: "create-and-publish-site",
         title: "Create and publish a polished website",
-        description: "Turn a brief into a responsive static website, review the result, publish it to Spacefast, and verify the live version.",
+        description: "Turn a brief into a responsive website, review the result, publish it to Spacefast, and verify the live version.",
         whenToUse: "Use when the user wants an agent to design, build, improve, or launch a new website rather than only upload an existing build.",
         keywords: ["create", "website", "design", "build", "responsive", "launch", "publish"],
         runtimes: BOTH_RUNTIMES,
@@ -14,7 +14,7 @@ export const SPACEFAST_SKILLS = [
         instructions: [
             "Clarify the audience, goal, required content, brand constraints, and desired call to action. If the visual direction is open, propose two or three distinct directions and choose one with the user.",
             "Inspect the existing workspace before editing. Reuse its framework, package manager, components, assets, and build conventions when they are sound.",
-            "Build a focused, accessible static experience with a clear hierarchy, real content, responsive layouts, useful interaction states, and no placeholder copy. Keep the main path simple and put secondary detail behind progressive disclosure.",
+            "Build a focused, accessible experience with a clear hierarchy, real content, responsive layouts, useful interaction states, and no placeholder copy. Keep the main path simple and put secondary detail behind progressive disclosure.",
             "Run the real build and inspect the result at mobile and desktop widths. Fix overflow, illegible contrast, broken links, missing assets, keyboard traps, and avoidable layout shift.",
             "Review the workspace diff and summarize material design or content judgments before publishing. Never include API keys, claim credentials, upload credentials, or local auth state in the artifact.",
             "Publish the built output with `publish`. Present Open as the reusable access link and Claim as the one-time ownership link. Treat live and immutable-version URLs as receipt metadata, not extra actions.",
@@ -37,14 +37,14 @@ export const SPACEFAST_SKILLS = [
     {
         name: "publish-and-verify",
         title: "Publish and verify",
-        description: "Publish an existing static build, confirm the new version is actually live, and return the useful URLs without leaking credentials.",
+        description: "Publish an existing build, confirm the new version is actually live, and return the useful URLs without leaking credentials.",
         whenToUse: "Use when the artifact already exists and the user wants it published or updated.",
         keywords: ["publish", "deploy", "live", "verify", "version", "claim"],
         runtimes: BOTH_RUNTIMES,
         tools: ["publish", "status", "diagnose"],
         docs: ["publishing", "workflow/publish-receipt", "workflow/secret-handling"],
         instructions: [
-            "Identify the actual publish root or build output. Run the real build first when the source tree is not itself the static artifact.",
+            "Identify the actual publish root or build output. Run the real build first when the source tree is not itself the artifact to publish.",
             "Publish with `publish`. For an anonymous On-Device publish, keep the claim credential in local custody and return only the claim URL and expiry; never expose or ask the user to paste the raw token.",
             "Report the bare Live URL, private Access URL when present, immutable Version URL when present, anonymous Claim URL and expiry when present, plus actionable diagnostics.",
         ],

package/dist/test-helpers/fetch-stub.js

@@ -2,6 +2,7 @@ import { errorDocsUrl, errorTitle, PROBLEM_CONTENT_TYPE } from "../contracts/err
 /** The original fetch implementation captured before a test installs a stub. */
 export const realFetch = globalThis.fetch;
 export function stubFetch(handler) {
+    // SAFETY: The wrapper accepts fetch's parameter types and always resolves to the handler's Response.
     globalThis.fetch = (async (input, init) => handler(input instanceof Request && init === undefined ? input : new Request(input, init)));
 }
 export function restoreFetch() {

package/dist/utils/build-settings.d.ts

@@ -1,3 +1,4 @@
+import { type SpaceCronConfig } from "../contracts/space-config.js";
 export type BuildSettingsInput = {
     fileNames: Iterable<string>;
     packageJson?: string | null | undefined;
@@ -24,7 +25,7 @@ export type BuildAnalyzerCandidateRankInput = {
     rootDirectory: string | null;
     fileNames: Iterable<string>;
 };
-export declare function hasWorkspaceSignal(fileNames: Iterable<string>, packageJsonText?: string | null): unknown;
+export declare function hasWorkspaceSignal(fileNames: Iterable<string>, packageJsonText?: string | null): boolean;
 export declare function rankBuildAnalyzerCandidate(input: BuildAnalyzerCandidateRankInput): {
     confidence: number;
     reasons: string[];
@@ -43,6 +44,7 @@ export type PlatformConfig = {
     redirects: Array<Record<string, unknown>>;
     rewrites: Array<Record<string, unknown>>;
     headers: Array<Record<string, unknown>>;
+    crons: Array<Record<string, unknown>>;
     unsupportedFeatures: string[];
 };
 export declare function stringField(value: Record<string, unknown> | null, key: string): string | null;
@@ -51,7 +53,9 @@ export declare function detectPlatformConfigs(input: Omit<BuildSettingsInput, "f
 export type PlatformRoutingConversion = {
     redirectLines: string[];
     headerBlocks: string[];
+    crons: SpaceCronConfig[];
     notes: string[];
 };
 export declare function convertPlatformRouting(configs: PlatformConfig[]): PlatformRoutingConversion;
+export declare const BUILD_MARKER_FILE_NAMES: Set<string>;
 export declare function detectBuildSettings(input: BuildSettingsInput): DetectedBuildSettings;

package/dist/utils/build-settings.js

@@ -1,5 +1,6 @@
 import { load as parseYaml } from "js-yaml";
 import { parse as parseToml } from "smol-toml";
+import { SPACE_CONFIG_CAPS, spaceCronKey, spaceCronSchema, } from "../contracts/space-config.js";
 export const BUILD_ANALYZER_CANDIDATE_ROOTS = ["apps", "packages", "sites", "docs"];
 const PACKAGE_MANAGER_ONLY_FILES = new Set([
     "package.json",
@@ -12,12 +13,15 @@ const PACKAGE_MANAGER_ONLY_FILES = new Set([
     "Gemfile",
     "Gemfile.lock",
 ]);
+const WORKSPACE_ROOT_FILES = new Set([
+    "pnpm-workspace.yaml",
+    "turbo.json",
+    "nx.json",
+    "lerna.json",
+]);
 export function hasWorkspaceSignal(fileNames, packageJsonText) {
     const names = new Set(fileNames);
-    if (names.has("pnpm-workspace.yaml") ||
-        names.has("turbo.json") ||
-        names.has("nx.json") ||
-        names.has("lerna.json")) {
+    if ([...WORKSPACE_ROOT_FILES].some((file) => names.has(file))) {
         return true;
     }
     if (!packageJsonText) {
@@ -25,10 +29,14 @@ export function hasWorkspaceSignal(fileNames, packageJsonText) {
     }
     try {
         const parsed = JSON.parse(packageJsonText);
-        return (Array.isArray(parsed.workspaces) ||
-            (parsed.workspaces &&
-                typeof parsed.workspaces === "object" &&
-                Array.isArray(parsed.workspaces.packages)));
+        if (Array.isArray(parsed.workspaces)) {
+            return true;
+        }
+        if (!parsed.workspaces || typeof parsed.workspaces !== "object") {
+            return false;
+        }
+        // SAFETY: The preceding non-null object check proves workspaces can carry an optional packages property.
+        return Array.isArray(parsed.workspaces.packages);
     }
     catch {
         return false;
@@ -78,6 +86,7 @@ function parseJsonObject(value) {
     }
     try {
         const parsed = JSON.parse(value);
+        // SAFETY: The conditional establishes parsed is a non-null, non-array object before returning it as a dictionary.
         return parsed && typeof parsed === "object" && !Array.isArray(parsed)
             ? parsed
             : null;
@@ -98,6 +107,7 @@ function parseTomlObject(value) {
     }
     try {
         const parsed = parseToml(value);
+        // SAFETY: The conditional establishes parsed is a non-null, non-array object before returning it as a dictionary.
         return parsed && typeof parsed === "object" && !Array.isArray(parsed)
             ? parsed
             : null;
@@ -112,6 +122,7 @@ function parseYamlObject(value) {
     }
     try {
         const parsed = parseYaml(value);
+        // SAFETY: The conditional establishes parsed is a non-null, non-array object before returning it as a dictionary.
         return parsed && typeof parsed === "object" && !Array.isArray(parsed)
             ? parsed
             : null;
@@ -130,6 +141,7 @@ export function numberField(value, key) {
 }
 function objectField(value, key) {
     const field = value?.[key];
+    // SAFETY: The conditional establishes field is a non-null, non-array object before returning it as a dictionary.
     return field && typeof field === "object" && !Array.isArray(field)
         ? field
         : null;
@@ -155,11 +167,11 @@ function vercelConfig(value) {
         redirects: arrayField(config, "redirects"),
         rewrites: arrayField(config, "rewrites"),
         headers: arrayField(config, "headers"),
+        crons: arrayField(config, "crons"),
         unsupportedFeatures: [
             ...("functions" in config ? ["Vercel functions are not converted."] : []),
             ...("middleware" in config ? ["Vercel middleware is not converted."] : []),
             ...("images" in config ? ["Vercel image optimization config is not converted."] : []),
-            ...("crons" in config ? ["Vercel cron jobs are not converted."] : []),
         ],
     };
 }
@@ -179,6 +191,9 @@ function netlifyConfig(value) {
         redirects: arrayField(config, "redirects"),
         rewrites: [],
         headers: arrayField(config, "headers"),
+        // Netlify has no scheduled-request config: its scheduled functions are
+        // declared in function code, which this importer does not read.
+        crons: [],
         unsupportedFeatures: [
             ...("functions" in config ? ["Netlify functions are not converted."] : []),
             ...("edge_functions" in config ? ["Netlify edge functions are not converted."] : []),
@@ -224,6 +239,7 @@ function cloudflarePagesConfig(input) {
         redirects: [],
         rewrites: [],
         headers: [],
+        crons: [],
         unsupportedFeatures,
     };
 }
@@ -387,6 +403,7 @@ function convertVercelHeaderRule(rule, out) {
     const entries = rule.headers;
     const headers = (Array.isArray(entries) ? entries : [])
         .map((entry) => {
+        // SAFETY: The conditional establishes entry is a non-null object before reading dictionary properties.
         const header = entry && typeof entry === "object" ? entry : null;
         const key = stringField(header, "key");
         const value = header && typeof header.value === "string" ? header.value : null;
@@ -425,8 +442,47 @@ function convertNetlifyHeaderRule(rule, out) {
     }
     out.headerBlocks.push(headerBlock(matcher, headers));
 }
+/**
+ * One `vercel.json` cron entry into an `sf.jsonc` `crons` entry.
+ *
+ * Both sides are `{ path, schedule }` over a literal path and a five-field
+ * crontab expression, so a valid Vercel cron converts verbatim — there is no
+ * translation to get wrong. What this guards is the tail: Vercel accepts paths
+ * and schedules our grammar does not, and it has no per-project cap the way we
+ * do. Every rejection names the entry, because a scheduled job that silently
+ * stops existing is the one migration failure nobody notices until the work
+ * has not run for a week.
+ */
+function convertVercelCron(rule, out) {
+    const path = stringField(rule, "path");
+    const schedule = stringField(rule, "schedule");
+    const label = `vercel.json cron ${path ?? "(missing path)"}`;
+    if (!path || !schedule) {
+        out.notes.push(`${label}: skipped — missing path or schedule.`);
+        return;
+    }
+    const parsed = spaceCronSchema.safeParse({ path, schedule });
+    if (!parsed.success) {
+        out.notes.push(`${label}: skipped — ${parsed.error.issues.map((issue) => issue.message).join("; ")}`);
+        return;
+    }
+    if (out.crons.some((entry) => spaceCronKey(entry.path) === spaceCronKey(path))) {
+        out.notes.push(`${label}: skipped — another cron already schedules this path.`);
+        return;
+    }
+    if (out.crons.length >= SPACE_CONFIG_CAPS.crons) {
+        out.notes.push(`${label}: skipped — at most ${SPACE_CONFIG_CAPS.crons} crons are supported.`);
+        return;
+    }
+    out.crons.push(parsed.data);
+}
 export function convertPlatformRouting(configs) {
-    const out = { redirectLines: [], headerBlocks: [], notes: [] };
+    const out = {
+        redirectLines: [],
+        headerBlocks: [],
+        crons: [],
+        notes: [],
+    };
     for (const config of configs) {
         if (config.platform === "vercel") {
             for (const rule of config.redirects) {
@@ -438,6 +494,9 @@ export function convertPlatformRouting(configs) {
             for (const rule of config.headers) {
                 convertVercelHeaderRule(rule, out);
             }
+            for (const rule of config.crons) {
+                convertVercelCron(rule, out);
+            }
         }
         if (config.platform === "netlify") {
             // Netlify expresses rewrites as 200-status redirects; both arrive in
@@ -671,6 +730,19 @@ const FRAMEWORKS = [
         defaultBuildCommand: "bundle exec middleman build",
     },
 ];
+// Every file name the build analyzer keys on: package manifests, lockfiles,
+// workspace roots, and the platform and framework configs it detects a build
+// from. An archive carrying any of them is a project to build, not a website.
+export const BUILD_MARKER_FILE_NAMES = new Set([
+    ...PACKAGE_MANAGER_ONLY_FILES,
+    ...WORKSPACE_ROOT_FILES,
+    "vercel.json",
+    "netlify.toml",
+    "wrangler.toml",
+    "wrangler.json",
+    "wrangler.jsonc",
+    ...FRAMEWORKS.flatMap((framework) => framework.configFiles ?? []),
+]);
 function frameworkForPreset(frameworkPreset) {
     return FRAMEWORKS.find((framework) => framework.preset === frameworkPreset) ?? null;
 }

package/dist/utils/canonical-json.js

@@ -12,6 +12,7 @@ export function canonicalJson(value) {
         return `[${value.map(canonicalJson).join(",")}]`;
     }
     if (value && typeof value === "object") {
+        // SAFETY: This branch establishes value is a non-null object before enumerating its entries.
         return `{${Object.entries(value)
             .toSorted(([left], [right]) => left.localeCompare(right))
             .map(([key, entry]) => `${JSON.stringify(key)}:${canonicalJson(entry)}`)

package/dist/utils/concurrency.js

@@ -10,6 +10,7 @@ export async function mapConcurrent(items, limit, mapper) {
         if (index >= items.length) {
             return;
         }
+        // SAFETY: the bounds check above proves this index addresses an item in the input array.
         results[index] = await mapper(items[index], index);
         await worker();
     }

package/dist/utils/credential-policy.js

@@ -141,7 +141,7 @@ export function policyIsSubsetOfGrantor(requested, grantor) {
         return statement.actions.every((action) => statement.resources.every((resource) => grantorAllows(grantor, action, resource, statement.conditions)));
     }) && grantorDeniesArePreserved(requested, grantor));
 }
-// Request-time evaluation (internal-docs/platform.md IAM-lite): explicit deny wins,
+// Request-time evaluation (the platform spec IAM-lite): explicit deny wins,
 // explicit allow permits, otherwise implicit deny. Condition keys are ANDed and an
 // unresolvable condition attribute fails closed (see `conditionsMatch`).
 export function policyAllows(input) {
@@ -152,7 +152,7 @@ export function policyAllows(input) {
     return resources.some((resource) => matchesEffect(input.policy, "allow", input.action, resource, input.conditions, "request"));
 }
 // The tenants a credential's policy grants any access to. Drives tenant
-// selection (internal-docs/platform.md Tenant): `X-Spacefast-Tenant-Id` may pick
+// selection (the platform spec Tenant): `X-Spacefast-Tenant-Id` may pick
 // one granted tenant but is never an authority by itself, and a token spanning
 // multiple tenants must fail ambiguous requests with `tenant_selection_required`.
 export function grantedTenantsFromPolicy(policy) {
@@ -259,7 +259,7 @@ function resourceMatches(pattern, resource) {
     if (pattern.endsWith("/*")) {
         return resource === pattern.slice(0, -2) || resource.startsWith(pattern.slice(0, -1));
     }
-    // A tenant-rooted resource is scope-wide (internal-docs/platform.md L617/L879:
+    // A tenant-rooted resource is scope-wide (the platform spec:
     // `stt://tenant/{t}` is a grantable StatticResource and resource grants cover
     // their subtree): it covers every resource inside that tenant. This is the
     // tenant-scoped (partner/agency) credential shape.
@@ -273,6 +273,7 @@ function conditionsMatch(statementConditions, contextConditions, effect, mode) {
         return true;
     }
     return Object.entries(statementConditions).every(([key, value]) => {
+        // SAFETY: Object.entries obtains key from the named RequestCondition object immediately above.
         const resolved = contextConditions?.[key];
         if (resolved === undefined && mode === "request") {
             // Fail closed on unresolvable condition attributes: the condition never

package/dist/utils/dns-instructions.js

@@ -15,15 +15,15 @@ export function addressDnsInstructionsForHostname(input) {
             normalizeDnsName(instruction.name) !== hostname) {
             return [];
         }
-        return [
-            {
-                type: instruction.type,
-                name: instruction.name,
-                value: instruction.value,
-                purpose: instruction.purpose,
-                ...(instruction.ttl === undefined ? {} : { ttl: instruction.ttl }),
-            },
-        ];
+        const result = {
+            type: instruction.type,
+            name: instruction.name,
+            value: instruction.value,
+            purpose: instruction.purpose,
+        };
+        if (instruction.ttl !== undefined)
+            result.ttl = instruction.ttl;
+        return [result];
     });
 }
 function normalizeAddress(value) {

package/dist/utils/error-code.js

@@ -3,5 +3,6 @@ export function hasErrorCode(error, code) {
     return (error !== null &&
         typeof error === "object" &&
         "code" in error &&
+        // SAFETY: The preceding checks prove error is a non-null object with a code property.
         error.code === code);
 }

package/dist/utils/grant-decision.fixtures.json

@@ -1438,8 +1438,8 @@
                 "principal": {}
             },
             "expected": {
-                "capabilities": ["page.view"],
-                "matchedGrantIds": ["grt_all_versions"]
+                "capabilities": [],
+                "matchedGrantIds": []
             },
             "phpProjectionCompiles": true
         },

package/dist/utils/grants.js

@@ -27,8 +27,10 @@ function targetMatches(selector, target) {
             return target.kind === "version" && target.versionId === selector.versionId;
         case "branch":
             return target.kind === "branch" && target.branch === selector.branch;
+        // Immutable Version hosts only. The live host is its own target: sharing
+        // "every Version" does not thereby publish the live site.
         case "all_versions":
-            return target.kind === "live" || target.kind === "version";
+            return target.kind === "version";
     }
     throw new Error("Unsupported Grant target.");
 }

package/dist/utils/local-space-state.d.ts

@@ -22,6 +22,12 @@ export declare const localSpaceLinkSchema: z.ZodObject<{
     apiBaseUrl: z.ZodOptional<z.ZodString>;
 }, z.core.$loose>;
 export declare const LOCAL_SPACE_STATE_SCHEMA_VERSION = 1;
+export declare const creationAttemptSchema: z.ZodObject<{
+    key: z.ZodString;
+    principal: z.ZodString;
+    kind: z.ZodLiteral<"authenticated">;
+    createdAt: z.ZodString;
+}, z.core.$strict>;
 export declare const localSpaceStateSchema: z.ZodObject<{
     schemaVersion: z.ZodLiteral<1>;
     spaceId: z.ZodOptional<z.ZodString>;
@@ -41,22 +47,14 @@ export declare const localSpaceStateSchema: z.ZodObject<{
     pendingPublish: z.ZodOptional<z.ZodObject<{
         key: z.ZodString;
         principal: z.ZodString;
-        kind: z.ZodEnum<{
-            anonymous: "anonymous";
-            authenticated: "authenticated";
-        }>;
-        intent: z.ZodOptional<z.ZodString>;
+        kind: z.ZodLiteral<"authenticated">;
         createdAt: z.ZodString;
     }, z.core.$strict>>;
     /** Settled creation receipt identity retained for invocations that began before its commit. */
     creationReplay: z.ZodOptional<z.ZodObject<{
         key: z.ZodString;
         principal: z.ZodString;
-        kind: z.ZodEnum<{
-            anonymous: "anonymous";
-            authenticated: "authenticated";
-        }>;
-        intent: z.ZodOptional<z.ZodString>;
+        kind: z.ZodLiteral<"authenticated">;
         createdAt: z.ZodString;
     }, z.core.$strict>>;
     /** Random replay capability reserved before consuming a claim credential. */
@@ -147,7 +145,6 @@ export declare function mutateLocalSpaceState(root: string, mutate: (current: Lo
     /** Fault-injection observer used to synchronize concurrency tests. */
     onConflict?: (() => void | Promise<void>) | undefined;
 }): Promise<LocalSpaceStateFile>;
-export declare function writeLocalSpaceState(root: string, state: LocalSpaceStateWrite): Promise<string>;
 /** Reserve random replay custody before a claim token can be consumed. */
 export declare function reserveLocalCredentialReplay(root: string, input: {
     operation: LocalCredentialReplayOperation;

package/dist/utils/local-space-state.js

@@ -29,6 +29,17 @@ export const localSpaceLinkSchema = z
 })
     .loose();
 export const LOCAL_SPACE_STATE_SCHEMA_VERSION = 1;
+// One reservation, two slots: it is written as `pendingPublish` and moved to
+// `creationReplay` once its receipt commits. Space creation is the only
+// mutation that reserves one — credential-free publishes are not idempotent.
+export const creationAttemptSchema = z
+    .object({
+    key: z.string().min(1),
+    principal: z.string().regex(/^[0-9a-f]{64}$/),
+    kind: z.literal("authenticated"),
+    createdAt: z.string().datetime(),
+})
+    .strict();
 export const localSpaceStateSchema = z.strictObject({
     schemaVersion: z.literal(LOCAL_SPACE_STATE_SCHEMA_VERSION),
     spaceId: z.string().min(1).optional(),
@@ -45,27 +56,9 @@ export const localSpaceStateSchema = z.strictObject({
     /** Secret per-checkout entropy used only to namespace replay-safe first publishes. */
     anonymousPublishNonce: z.string().min(32).optional(),
     /** Unsettled first-publish mutation. Retries must reuse this exact key. */
-    pendingPublish: z
-        .object({
-        key: z.string().min(1),
-        principal: z.string().regex(/^[0-9a-f]{64}$/),
-        kind: z.enum(["anonymous", "authenticated"]),
-        intent: z.string().min(1).optional(),
-        createdAt: z.string().datetime(),
-    })
-        .strict()
-        .optional(),
+    pendingPublish: creationAttemptSchema.optional(),
     /** Settled creation receipt identity retained for invocations that began before its commit. */
-    creationReplay: z
-        .object({
-        key: z.string().min(1),
-        principal: z.string().regex(/^[0-9a-f]{64}$/),
-        kind: z.enum(["anonymous", "authenticated"]),
-        intent: z.string().min(1).optional(),
-        createdAt: z.string().datetime(),
-    })
-        .strict()
-        .optional(),
+    creationReplay: creationAttemptSchema.optional(),
     /** Random replay capability reserved before consuming a claim credential. */
     pendingCredentialReplay: z
         .object({
@@ -360,10 +353,6 @@ export async function mutateLocalSpaceState(root, mutate, options = {}) {
     /* eslint-enable no-await-in-loop */
     throw new LocalSpaceStateConflictError("Local Spacefast state stayed busy for too long.");
 }
-export async function writeLocalSpaceState(root, state) {
-    await mutateLocalSpaceState(root, () => state);
-    return localSpaceStatePath(root);
-}
 function credentialFingerprint(credential) {
     return createHash("sha256").update(credential).digest("hex");
 }

package/dist/utils/one-shot-replay.d.ts

@@ -11,4 +11,7 @@ export type OneShotReplayIdentity = {
  */
 export declare function createOneShotReplayIdentity(prefix: string): OneShotReplayIdentity;
 /** Production headers for one one-shot attempt (or one device-poll sequence). */
-export declare function oneShotReplayHeaders(identity: OneShotReplayIdentity, sequence?: number): Record<"idempotency-key" | "x-spacefast-idempotency-principal", string>;
+export declare function oneShotReplayHeaders(identity: OneShotReplayIdentity, sequence?: number): {
+    "idempotency-key": string;
+    "x-spacefast-idempotency-principal": string;
+};