@spacefast/common 0.0.13 → 0.0.17

package/dist/utils/domain-diagnostics.js

@@ -3,8 +3,20 @@ import { addressDnsInstructionIsObserved, addressDnsInstructionsForHostname, uns
 export function domainRequiredActions(hostnameDiagnostics) {
     const actions = [];
     for (const entry of hostnameDiagnostics) {
-        const unsupportedRecords = entry.dns.records
-            ? unsupportedAddressDnsRecordsForHostname({ ...entry, records: entry.dns.records })
+        const records = entry.dns.records
+            ? {
+                a: entry.dns.records.a ?? [],
+                aaaa: entry.dns.records.aaaa ?? [],
+            }
+            : undefined;
+        const dnsInstructions = entry.dnsInstructions ?? [];
+        const providerIps = entry.providerIps ?? [];
+        const unsupportedRecords = records
+            ? unsupportedAddressDnsRecordsForHostname({
+                hostname: entry.hostname,
+                dnsInstructions,
+                records,
+            })
             : [];
         actions.push(...unsupportedRecords.map((record) => ({
             code: "dns_unaccepted_address",
@@ -12,13 +24,12 @@ export function domainRequiredActions(hostnameDiagnostics) {
             message: `Remove the ${record.type} record on ${record.name} with value ${record.value}; it does not match a Spacefast target for this hostname.`,
         })));
         if (!entry.dns.pointsToProvider) {
-            const routingInstructions = addressDnsInstructionsForHostname(entry);
-            const observedAddressRecords = entry.dns.records;
-            const missingRoutingInstructions = observedAddressRecords
-                ? routingInstructions.filter((instruction) => !addressDnsInstructionIsObserved({
-                    instruction,
-                    records: observedAddressRecords,
-                }))
+            const routingInstructions = addressDnsInstructionsForHostname({
+                hostname: entry.hostname,
+                dnsInstructions,
+            });
+            const missingRoutingInstructions = records
+                ? routingInstructions.filter((instruction) => !addressDnsInstructionIsObserved({ instruction, records }))
                 : routingInstructions;
             if (missingRoutingInstructions.length > 0) {
                 actions.push(...missingRoutingInstructions.map((instruction) => ({
@@ -28,7 +39,7 @@ export function domainRequiredActions(hostnameDiagnostics) {
                 })));
             }
             else if (routingInstructions.length === 0) {
-                const targets = entry.providerIps.length > 0 ? entry.providerIps.join(", ") : "Spacefast";
+                const targets = providerIps.length > 0 ? providerIps.join(", ") : "Spacefast";
                 actions.push({
                     code: "dns_not_pointing",
                     hostname: entry.hostname,

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

@@ -13,15 +13,18 @@ export declare const LOCAL_SPACE_STATE_FILE_NAME = "state.json";
  * `.spacefast/state.json` is the local credential/cache axis: it records the
  * resolved `spaceId`, provider `apiUrl`, anonymous `claimToken` before claim,
  * durable `accessToken` after continuation, and small publish caches such as
- * `lastVersionId`. It is secret, machine-written, gitignored, and merge-written
- * so newer tools preserve unknown fields from older/newer tools.
+ * `lastVersionId`. It is secret, machine-written, gitignored, and merge-written.
+ * The strict versioned schema fails closed instead of letting an older tool
+ * reinterpret fields written under a contract it does not understand.
  */
 export declare const localSpaceLinkSchema: z.ZodObject<{
     team: z.ZodOptional<z.ZodString>;
     space: z.ZodString;
     apiBaseUrl: z.ZodOptional<z.ZodString>;
 }, z.core.$loose>;
+export declare const LOCAL_SPACE_STATE_SCHEMA_VERSION = 1;
 export declare const localSpaceStateSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
     spaceId: z.ZodOptional<z.ZodString>;
     apiUrl: z.ZodOptional<z.ZodString>;
     teamSlug: z.ZodOptional<z.ZodString>;
@@ -30,11 +33,52 @@ export declare const localSpaceStateSchema: z.ZodObject<{
     expiresAt: z.ZodOptional<z.ZodString>;
     accessToken: z.ZodOptional<z.ZodString>;
     lastVersionId: z.ZodOptional<z.ZodString>;
+    pendingOperationId: z.ZodOptional<z.ZodString>;
     lastVersionUrl: z.ZodOptional<z.ZodString>;
     lastSpaceUrl: z.ZodOptional<z.ZodString>;
-}, z.core.$loose>;
+    /** Secret per-checkout entropy used only to namespace replay-safe first publishes. */
+    anonymousPublishNonce: z.ZodOptional<z.ZodString>;
+    /** Unsettled first-publish mutation. Retries must reuse this exact key. */
+    pendingPublish: z.ZodOptional<z.ZodObject<{
+        key: z.ZodString;
+        principal: z.ZodString;
+        kind: z.ZodEnum<{
+            anonymous: "anonymous";
+            authenticated: "authenticated";
+        }>;
+        intent: z.ZodOptional<z.ZodString>;
+        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>;
+        createdAt: z.ZodString;
+    }, z.core.$strict>>;
+    /** Random replay capability reserved before consuming a claim credential. */
+    pendingCredentialReplay: z.ZodOptional<z.ZodObject<{
+        operation: z.ZodEnum<{
+            "claim-rotate": "claim-rotate";
+            "claim-exchange": "claim-exchange";
+        }>;
+        credentialFingerprint: z.ZodString;
+        key: z.ZodString;
+        principal: z.ZodString;
+        createdAt: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
 export type LocalSpaceLink = z.infer<typeof localSpaceLinkSchema>;
 export type LocalSpaceStateFile = z.infer<typeof localSpaceStateSchema>;
+export type LocalSpaceStateWrite = Omit<LocalSpaceStateFile, "schemaVersion"> & {
+    schemaVersion?: typeof LOCAL_SPACE_STATE_SCHEMA_VERSION;
+};
+export type LocalCredentialReplay = NonNullable<LocalSpaceStateFile["pendingCredentialReplay"]>;
+export type LocalCredentialReplayOperation = LocalCredentialReplay["operation"];
 export type DiscoveredLocalSpaceState = {
     root: string;
     statePath: string | null;
@@ -48,6 +92,7 @@ export type DiscoveredLocalSpaceState = {
     claimUrl: string | undefined;
     expiresAt: string | undefined;
     lastVersionId: string | undefined;
+    pendingOperationId: string | undefined;
 };
 export type SaveLocalSpaceStateInput = {
     spaceId: string;
@@ -58,9 +103,26 @@ export type SaveLocalSpaceStateInput = {
     expiresAt?: string | undefined;
     accessToken?: string | undefined;
     lastVersionId?: string | undefined;
+    pendingOperationId?: string | undefined;
     lastVersionUrl?: string | undefined;
     lastSpaceUrl?: string | undefined;
+    /** Required when replacing one shown-once credential with another. */
+    expectedCredential?: {
+        claimToken?: string | undefined;
+        accessToken?: string | undefined;
+    };
+    /** Replay reservation completed by this shown-once credential replacement. */
+    credentialReplay?: LocalCredentialReplay | undefined;
+    /** Explicit relinks may replace another Space; ordinary cache writes may not. */
+    replaceSpace?: boolean | undefined;
 };
+export declare class LocalSpaceStateConflictError extends Error {
+    name: string;
+}
+export declare class LocalSpaceStateError extends Error {
+    readonly path: string;
+    constructor(filePath: string, cause?: unknown);
+}
 export declare function localSpaceStateDir(root: string): string;
 export declare function localSpaceStatePath(root: string): string;
 export declare function localSpaceLinkPath(root: string): string;
@@ -83,7 +145,19 @@ export declare function readLocalSpaceStateAt(root: string): Promise<DiscoveredL
 export declare function findUpward<T>(probe: (dir: string) => Promise<T | null>, startDir?: string, boundary?: string): Promise<T | null>;
 export declare function discoverLocalSpaceState(startDir?: string, boundary?: string): Promise<DiscoveredLocalSpaceState | null>;
 export declare function writeLocalSpaceLink(root: string, link: LocalSpaceLink): Promise<string>;
-export declare function writeLocalSpaceState(root: string, state: LocalSpaceStateFile): Promise<string>;
+export declare function mutateLocalSpaceState(root: string, mutate: (current: LocalSpaceStateFile) => LocalSpaceStateWrite, options?: {
+    beforeCommit?: (() => void | Promise<void>) | undefined;
+    afterBackup?: (() => void | Promise<void>) | undefined;
+    /** 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;
+    claimToken: string;
+    allowUnstoredClaimToken?: boolean | undefined;
+}): Promise<LocalCredentialReplay>;
 export declare function saveLocalSpaceState(root: string, input: SaveLocalSpaceStateInput): Promise<{
     statePath: string;
     linkPath: string;