@caelo-cms/shared 0.10.55 → 0.10.58

package/src/redirect-emit.test.ts

@@ -153,20 +153,22 @@ describe("GCP URL-map rules", () => {
   });
 
   it("refuses a plan over the 1,000-predicate quota with the counts, before any change", () => {
+    // The base rule routes /api/* and the remote-MCP discovery paths (#806).
+    expect(GCP_PUBLIC_BASE_PATHS).toHaveLength(3);
     const base = [{ paths: [...GCP_PUBLIC_BASE_PATHS] }];
     const rows = (n: number) => Array.from({ length: n }, (_, i) => row(`/p${i}`, "/x"));
-    expect(() => assertGcpRedirectBudget(planOf(rows(499)), base)).not.toThrow();
+    expect(() => assertGcpRedirectBudget(planOf(rows(498)), base)).not.toThrow();
     try {
-      assertGcpRedirectBudget(planOf(rows(500)), base);
+      assertGcpRedirectBudget(planOf(rows(499)), base);
       throw new Error("expected GcpUrlMapBudgetError");
     } catch (e) {
       expect(e).toBeInstanceOf(GcpUrlMapBudgetError);
       expect((e as GcpUrlMapBudgetError).predicatesNeeded).toBe(1001);
-      expect((e as Error).message).toContain("500 redirect(s) need 1001 paths");
+      expect((e as Error).message).toContain("499 redirect(s) need 1001 paths");
       expect((e as Error).message).toContain("bulk_delete_redirects");
     }
     // File-like paths cost one predicate each.
-    const files = Array.from({ length: 999 }, (_, i) => row(`/p${i}.html`, "/x"));
+    const files = Array.from({ length: 997 }, (_, i) => row(`/p${i}.html`, "/x"));
     expect(() => assertGcpRedirectBudget(planOf(files), base)).not.toThrow();
   });
 

package/src/release-manifest.ts

@@ -71,12 +71,23 @@ export const SIGSTORE_BUNDLE_MEDIA_TYPE = "application/vnd.dev.sigstore.bundle.v
 /** Why fetching the artifact failed. */
 export type ReleaseArtifactErrorCode = "registry" | "artifact-shape" | "blob-digest";
 
+/** Why {@link fetchReleaseArtifact} failed. */
+export interface ReleaseArtifactError {
+  readonly code: ReleaseArtifactErrorCode;
+  readonly message: string;
+  /**
+   * Set on `registry` errors a retry may cure: the registry could not be
+   * reached, timed out, rate-limited (429) or failed (5xx). Absent when the
+   * registry answered that the manifest, tag or blob does not exist (404 and
+   * other 4xx) — retrying that changes nothing, so callers that would
+   * otherwise "try again later" must treat it as a verdict.
+   */
+  readonly transient?: true;
+}
+
 export type ReleaseArtifactResult =
   | { readonly ok: true; readonly manifestBytes: Uint8Array; readonly bundleBytes: Uint8Array }
-  | {
-      readonly ok: false;
-      readonly error: { readonly code: ReleaseArtifactErrorCode; readonly message: string };
-    };
+  | { readonly ok: false; readonly error: ReleaseArtifactError };
 
 /** Where and how {@link fetchReleaseArtifact} reaches the registry. */
 export interface ReleaseArtifactDeps {
@@ -101,6 +112,22 @@ const fail = (code: ReleaseArtifactErrorCode, message: string): ReleaseArtifactR
   error: { code, message },
 });
 
+/** A `registry` failure a retry may cure (see {@link ReleaseArtifactError.transient}). */
+const failTransient = (message: string): ReleaseArtifactResult => ({
+  ok: false,
+  error: { code: "registry", message, transient: true },
+});
+
+/** Whether an HTTP status says "try again" rather than "it does not exist". */
+function isTransientStatus(status: number): boolean {
+  return status >= 500 || status === 429 || status === 408;
+}
+
+/** A non-OK registry response as a failure, transient or not by its status. */
+function failStatus(status: number, message: string): ReleaseArtifactResult {
+  return isTransientStatus(status) ? failTransient(message) : fail("registry", message);
+}
+
 /**
  * Fetch the release manifest artifact of `version` and both its layers,
  * each checked against its content digest. Verifies NO signature: callers
@@ -120,6 +147,11 @@ export async function fetchReleaseArtifact(
       headers: { Accept: "application/vnd.oci.image.manifest.v1+json" },
     });
     if (!res.ok) {
+      if (isTransientStatus(res.status)) {
+        return failTransient(
+          `the registry at ${base} could not serve the release manifest of v${version} (HTTP ${res.status}); try again later.`,
+        );
+      }
       return fail(
         "registry",
         `no release manifest for v${version} at ${base} (HTTP ${res.status}). Releases before the signed manifest (epic #696) have none; otherwise check the version exists.`,
@@ -131,7 +163,7 @@ export async function fetchReleaseArtifact(
     }
     artifact = parsed.data;
   } catch (e) {
-    return fail("registry", `registry unreachable: ${e instanceof Error ? e.message : String(e)}`);
+    return failTransient(`registry unreachable: ${e instanceof Error ? e.message : String(e)}`);
   }
 
   if (artifact.artifactType !== RELEASE_MANIFEST_ARTIFACT_TYPE) {
@@ -153,7 +185,7 @@ export async function fetchReleaseArtifact(
 
   const blob = async (layerDigest: string): Promise<Uint8Array | ReleaseArtifactResult> => {
     const res = await deps.fetch(`${base}/blobs/${layerDigest}`);
-    if (!res.ok) return fail("registry", `blob ${layerDigest}: HTTP ${res.status}`);
+    if (!res.ok) return failStatus(res.status, `blob ${layerDigest}: HTTP ${res.status}`);
     const bytes = new Uint8Array(await res.arrayBuffer());
     const actual = await sha256Digest(bytes);
     if (actual !== layerDigest) {
@@ -171,7 +203,7 @@ export async function fetchReleaseArtifact(
     if (!(bundleBytes instanceof Uint8Array)) return bundleBytes;
     return { ok: true, manifestBytes, bundleBytes };
   } catch (e) {
-    return fail("registry", `registry unreachable: ${e instanceof Error ? e.message : String(e)}`);
+    return failTransient(`registry unreachable: ${e instanceof Error ? e.message : String(e)}`);
   }
 }
 

package/src/theme-normalize-typography-subfields.test.ts

@@ -0,0 +1,54 @@
+// SPDX-License-Identifier: MPL-2.0
+/**
+ * Regression: saving the Typography tab posts every sub-field of a named
+ * style as its own `typography.<style>.<sub>` key, with lineHeight /
+ * fontWeight coerced to numbers. Numbers used to skip the composite wrap
+ * (so `$value` became a bare `1.6`) and sibling sub-fields overwrote each
+ * other on the shared composite path.
+ */
+import { describe, expect, it } from "bun:test";
+import { normalizeTokens } from "./theme-normalize.js";
+import { applyDtcgWrites, themeDocument } from "./themes.js";
+
+describe("normalizeTokens typography sub-fields", () => {
+  it("wraps numeric sub-field values into the composite", () => {
+    const r = normalizeTokens({ "typography.body.lineHeight": 1.6 });
+    expect(r.set["typography.body"]).toEqual({ lineHeight: 1.6 });
+  });
+
+  it("merges several sub-fields of one style into one composite", () => {
+    const r = normalizeTokens({
+      fontHeading: "Inter, sans-serif",
+      "typography.heading.fontSize": "3rem",
+      "typography.heading.fontWeight": 650,
+      "typography.heading.lineHeight": 1.08,
+    });
+    expect(r.set["typography.heading"]).toEqual({
+      fontFamily: "Inter, sans-serif",
+      fontSize: "3rem",
+      fontWeight: 650,
+      lineHeight: 1.08,
+    });
+    expect(r.canonicalPaths).toEqual(["typography.heading"]);
+  });
+
+  it("produces a valid document when applied over an existing theme", () => {
+    const current = {
+      typography: {
+        body: { $type: "typography", $value: { fontFamily: "Inter", fontSize: "1rem" } },
+      },
+    };
+    const r = normalizeTokens({
+      "typography.body.fontWeight": 400,
+      "typography.body.lineHeight": 1.6,
+    });
+    const next = applyDtcgWrites(current as never, r.set, r.types);
+    expect(themeDocument.safeParse(next).success).toBe(true);
+    expect((next.typography as Record<string, { $value: unknown }>).body?.$value).toEqual({
+      fontFamily: "Inter",
+      fontSize: "1rem",
+      fontWeight: 400,
+      lineHeight: 1.6,
+    });
+  });
+});

package/src/theme-normalize.ts

@@ -284,8 +284,14 @@ export function normalizeTokens(input: Record<string, unknown>): NormalizeResult
     // resulting document validates. applyDtcgWrites merges this into
     // any existing typography composite at the path so partial updates
     // don't erase sibling sub-fields.
+    // Numbers wrap too: the admin form coerces `.lineHeight` / `.fontWeight`
+    // to numbers, and an unwrapped `1.6` would replace the whole composite.
     let storedValue: unknown = rawValue;
-    if (resolved.compositeWrap && typeof rawValue === "string" && !ALIAS_REGEX.test(rawValue)) {
+    if (
+      resolved.compositeWrap &&
+      (typeof rawValue === "number" ||
+        (typeof rawValue === "string" && !ALIAS_REGEX.test(rawValue)))
+    ) {
       storedValue = { [resolved.compositeWrap]: rawValue };
     } else if (
       resolved.inferredType === "gradient" &&
@@ -303,10 +309,17 @@ export function normalizeTokens(input: Record<string, unknown>): NormalizeResult
       // rather than us silently inventing a gradient (CLAUDE.md §2).
       storedValue = gradientObjectToCss(rawValue as Record<string, unknown>) ?? rawValue;
     }
+    // Several sub-field inputs (`typography.body.fontSize` +
+    // `typography.body.lineHeight`) collapse onto the same composite
+    // path; merge them so the last one doesn't silently drop the others.
+    const prior = set[resolved.path];
+    if (resolved.compositeWrap && isPlainObject(prior) && isPlainObject(storedValue)) {
+      storedValue = { ...prior, ...storedValue };
+    }
     set[resolved.path] = storedValue;
     types[resolved.path] = resolved.inferredType;
     if (envelopeDescription !== undefined) descriptions[resolved.path] = envelopeDescription;
-    paths.push(resolved.path);
+    if (!paths.includes(resolved.path)) paths.push(resolved.path);
   }
 
   return { set, types, descriptions, canonicalPaths: paths };
@@ -721,3 +734,7 @@ function similarity(a: string, b: string): number {
 function tokenise(s: string): string[] {
   return s.split(/[.\-_]/).filter((p) => p.length > 0);
 }
+
+function isPlainObject(v: unknown): v is Record<string, unknown> {
+  return v !== null && typeof v === "object" && !Array.isArray(v);
+}

package/src/version.ts

@@ -22,7 +22,7 @@
  * follow standard SemVer.
  */
 
-export const CAELO_VERSION = "0.10.55";
+export const CAELO_VERSION = "0.10.58";
 
 /**
  * Deprecated alias for back-compat — early P17 work spelled this