fluncle 0.233.0 → 0.235.0

package/bin/fluncle.mjs

@@ -622,7 +622,7 @@ function parseVersion(version) {
 var currentVersion;
 var init_version = __esm(() => {
   init_output();
-  currentVersion = "0.233.0".trim() ? "0.233.0".trim() : "0.1.0";
+  currentVersion = "0.235.0".trim() ? "0.235.0".trim() : "0.1.0";
 });
 
 // src/update-notifier.ts
@@ -2335,7 +2335,7 @@ function parseVersion2(version) {
 var currentVersion2, latestReleaseUrl = "https://api.github.com/repos/mauricekleine/fluncle/releases/latest";
 var init_version2 = __esm(() => {
   init_output();
-  currentVersion2 = "0.233.0".trim() ? "0.233.0".trim() : "0.1.0";
+  currentVersion2 = "0.235.0".trim() ? "0.235.0".trim() : "0.1.0";
 });
 
 // ../../packages/registry/src/index.ts
@@ -2641,7 +2641,7 @@ var init_src = __esm(() => {
     },
     {
       exposedContent: [
-        "the galaxy factory — a draggable map of a finding's whole life, from the first CMD+F through the enrichment sweeps to the launch into the Galaxy"
+        "the Galaxy factory — a draggable map of a finding's whole life, from the first CMD+F through the enrichment sweeps to the launch into the Galaxy"
       ],
       kind: "web_route",
       name: "web.pipeline",
@@ -3059,6 +3059,28 @@ var init_src = __esm(() => {
       url: `${SITE}/robots.txt`,
       weights: { web: "tertiary" }
     },
+    {
+      apiFormat: "text/plain",
+      exposedContent: [
+        "RFC 9116 security.txt — where to send a vulnerability report, in the one place a researcher looks first"
+      ],
+      kind: "discovery",
+      name: "discovery.security-txt",
+      operatorNotes: "A static file, apps/web/public/.well-known/security.txt. It carries an `Expires` field the RFC requires a responder to keep in the future — when it lapses, a reporter reads the contact as stale. No probeConfig, exactly like robots.txt and llms.txt: a static asset the Worker never computes.",
+      route: "/.well-known/security.txt",
+      url: `${SITE}/.well-known/security.txt`,
+      weights: { web: "tertiary" }
+    },
+    {
+      apiFormat: "text/plain",
+      exposedContent: ["humans.txt — who made this, who is thanked, and what it is built with"],
+      kind: "discovery",
+      name: "discovery.humans",
+      operatorNotes: "A static file, apps/web/public/humans.txt — the human counterpart to robots.txt. Machine-fetched by convention, never browsed, which is why it sits under `discovery` beside robots.txt rather than as a web route.",
+      route: "/humans.txt",
+      url: `${SITE}/humans.txt`,
+      weights: { web: "tertiary" }
+    },
     {
       apiFormat: "text/markdown",
       discoveryUrl: `${SITE}/.well-known/api-catalog`,
@@ -3875,7 +3897,7 @@ var init_src = __esm(() => {
       ],
       kind: "cron",
       name: "cron.reconcile-hub-counts",
-      operatorNotes: "04:10 Amsterdam (after the 04:00 reach snapshot, before the 04:40 demand tick), a rave-02 host systemd timer (docs/agents/hermes/reconcile-hub-counts-timer/). The SELF-HEALING BACKSTOP under keystone 2's maintained hub counts: they are moved as DELTAS by every edge-writing path (recompute-from-truth measured 27,400 ms at 150k hosted vs ~200 ms for the delta form), and a maintained counter drifts silently — a missed write path, a non-atomic bulk op, or an out-of-band write (the catalogue-prune skill deletes tracks straight out of the database). Keystone 2's own rollout proved it on day one: the deploy-window skew left 44 artists / 3 albums / 1 label wrong until a manual reconcile. A bare trigger (the funnel-snapshot shape): fires the AGENT-tier reconcile_hub_counts op once and the Worker runs two statements per table — a grouped `UPDATE … FROM (… GROUP BY fk)` guarded by a counts-DIFFER predicate (so rowsAffected IS the corrected-row count) plus a zero-truth pass for an entity whose last track vanished. The artists source is PINNED to `track_artists JOIN tracks` so orphaned edges never count. Idempotent; zero LLM tokens; no new secret. The corrected-row numbers are the operator's DRIFT AUDIT — journalctl -u fluncle-reconcile-hub-counts.service | grep AUDIT. Source: docs/agents/hermes/scripts/reconcile-hub-counts.*.",
+      operatorNotes: "04:10 Amsterdam (after the 04:00 reach snapshot, before the 04:40 demand tick), a rave-02 host systemd timer (docs/agents/hermes/reconcile-hub-counts-timer/). The SELF-HEALING BACKSTOP under keystone 2's maintained hub counts: they are moved as DELTAS by every edge-writing path (recompute-from-truth measured 27,400 ms at 150k hosted vs ~200 ms for the delta form), and a maintained counter drifts silently — a missed write path, a non-atomic bulk op, or an out-of-band write (the catalogue-prune skill deletes tracks straight out of the database). Keystone 2's own rollout proved it on day one: the deploy-window skew left 44 artists / 3 albums / 1 label wrong until a manual reconcile. Walks the AGENT-tier reconcile_hub_counts op in bounded windows, one admitted database phase each: the Worker reads bounded keyset pages of entity rows beside their truth (never an aggregate inside a write transaction) and rewrites only disagreeing rows as compare-and-set point writes, so a concurrent maintained delta is never overwritten. The artists source is PINNED to `track_artists JOIN tracks` so orphaned edges never count. Idempotent; zero LLM tokens; no new secret. The corrected-row numbers are the operator's DRIFT AUDIT — journalctl -u fluncle-reconcile-hub-counts.service | grep AUDIT. Source: docs/agents/hermes/scripts/reconcile-hub-counts.*.",
       probeConfig: {
         cadenceMs: 24 * 60 * MINUTE_MS,
         cronName: "fluncle-reconcile-hub-counts",
@@ -5583,7 +5605,7 @@ var cuid, cuid2, ulid, xid, ksuid, nanoid, duration, guid, uuid = (version) => {
 }, email, _emoji = `^(\\p{Extended_Pictographic}|\\p{Emoji_Component})+$`, ipv4, ipv6, cidrv4, cidrv6, base64, base64url, httpProtocol, e164, dateSource = `(?:(?:\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-(?:(?:0[13578]|1[02])-(?:0[1-9]|[12]\\d|3[01])|(?:0[469]|11)-(?:0[1-9]|[12]\\d|30)|(?:02)-(?:0[1-9]|1\\d|2[0-8])))`, date, string = (params) => {
   const regex = params ? `[\\s\\S]{${params?.minimum ?? 0},${params?.maximum ?? ""}}` : `[\\s\\S]*`;
   return new RegExp(`^${regex}$`);
-}, integer, number, boolean, lowercase, uppercase;
+}, integer, number, boolean, _null, lowercase, uppercase;
 var init_regexes = __esm(() => {
   cuid = /^[cC][0-9a-z]{6,}$/;
   cuid2 = /^[0-9a-z]+$/;
@@ -5606,6 +5628,7 @@ var init_regexes = __esm(() => {
   integer = /^-?\d+$/;
   number = /^-?\d+(?:\.\d+)?$/;
   boolean = /^(?:true|false)$/i;
+  _null = /^null$/i;
   lowercase = /^[^A-Z]*$/;
   uppercase = /^[^a-z]*$/;
 });
@@ -6367,7 +6390,7 @@ function handleRefineResult(result, payload, input, inst) {
     payload.issues.push(issue(_iss));
   }
 }
-var $ZodType, $ZodString, $ZodStringFormat, $ZodGUID, $ZodUUID, $ZodEmail, $ZodURL, $ZodEmoji, $ZodNanoID, $ZodCUID, $ZodCUID2, $ZodULID, $ZodXID, $ZodKSUID, $ZodISODateTime, $ZodISODate, $ZodISOTime, $ZodISODuration, $ZodIPv4, $ZodIPv6, $ZodCIDRv4, $ZodCIDRv6, $ZodBase64, $ZodBase64URL, $ZodE164, $ZodJWT, $ZodNumber, $ZodNumberFormat, $ZodBoolean, $ZodUnknown, $ZodNever, $ZodArray, $ZodObject, $ZodObjectJIT, $ZodUnion, $ZodDiscriminatedUnion, $ZodIntersection, $ZodTuple, $ZodEnum, $ZodLiteral, $ZodTransform, $ZodOptional, $ZodExactOptional, $ZodNullable, $ZodDefault, $ZodPrefault, $ZodNonOptional, $ZodCatch, $ZodPipe, $ZodReadonly, $ZodTemplateLiteral, $ZodCustom;
+var $ZodType, $ZodString, $ZodStringFormat, $ZodGUID, $ZodUUID, $ZodEmail, $ZodURL, $ZodEmoji, $ZodNanoID, $ZodCUID, $ZodCUID2, $ZodULID, $ZodXID, $ZodKSUID, $ZodISODateTime, $ZodISODate, $ZodISOTime, $ZodISODuration, $ZodIPv4, $ZodIPv6, $ZodCIDRv4, $ZodCIDRv6, $ZodBase64, $ZodBase64URL, $ZodE164, $ZodJWT, $ZodNumber, $ZodNumberFormat, $ZodBoolean, $ZodNull, $ZodUnknown, $ZodNever, $ZodArray, $ZodObject, $ZodObjectJIT, $ZodUnion, $ZodDiscriminatedUnion, $ZodIntersection, $ZodTuple, $ZodRecord, $ZodEnum, $ZodLiteral, $ZodTransform, $ZodOptional, $ZodExactOptional, $ZodNullable, $ZodDefault, $ZodPrefault, $ZodNonOptional, $ZodCatch, $ZodPipe, $ZodReadonly, $ZodTemplateLiteral, $ZodLazy, $ZodCustom;
 var init_schemas = __esm(() => {
   init_checks();
   init_core();
@@ -6798,6 +6821,23 @@ var init_schemas = __esm(() => {
       return payload;
     };
   });
+  $ZodNull = /* @__PURE__ */ $constructor("$ZodNull", (inst, def) => {
+    $ZodType.init(inst, def);
+    inst._zod.pattern = _null;
+    inst._zod.values = new Set([null]);
+    inst._zod.parse = (payload, _ctx) => {
+      const input = payload.value;
+      if (input === null)
+        return payload;
+      payload.issues.push({
+        expected: "null",
+        code: "invalid_type",
+        input,
+        inst
+      });
+      return payload;
+    };
+  });
   $ZodUnknown = /* @__PURE__ */ $constructor("$ZodUnknown", (inst, def) => {
     $ZodType.init(inst, def);
     inst._zod.parse = (payload) => payload;
@@ -7236,6 +7276,132 @@ var init_schemas = __esm(() => {
       return handleTupleResults(itemResults, payload, items, input, optoutStart);
     };
   });
+  $ZodRecord = /* @__PURE__ */ $constructor("$ZodRecord", (inst, def) => {
+    $ZodType.init(inst, def);
+    inst._zod.parse = (payload, ctx) => {
+      const input = payload.value;
+      if (!isPlainObject(input)) {
+        payload.issues.push({
+          expected: "record",
+          code: "invalid_type",
+          input,
+          inst
+        });
+        return payload;
+      }
+      const proms = [];
+      const values = def.keyType._zod.values;
+      if (values) {
+        payload.value = {};
+        const recordKeys = new Set;
+        for (const key of values) {
+          if (typeof key === "string" || typeof key === "number" || typeof key === "symbol") {
+            recordKeys.add(typeof key === "number" ? key.toString() : key);
+            const keyResult = def.keyType._zod.run({ value: key, issues: [] }, ctx);
+            if (keyResult instanceof Promise) {
+              throw new Error("Async schemas not supported in object keys currently");
+            }
+            if (keyResult.issues.length) {
+              payload.issues.push({
+                code: "invalid_key",
+                origin: "record",
+                issues: keyResult.issues.map((iss) => finalizeIssue(iss, ctx, config3())),
+                input: key,
+                path: [key],
+                inst
+              });
+              continue;
+            }
+            const outKey = keyResult.value;
+            const result = def.valueType._zod.run({ value: input[key], issues: [] }, ctx);
+            if (result instanceof Promise) {
+              proms.push(result.then((result) => {
+                if (result.issues.length) {
+                  payload.issues.push(...prefixIssues(key, result.issues));
+                }
+                payload.value[outKey] = result.value;
+              }));
+            } else {
+              if (result.issues.length) {
+                payload.issues.push(...prefixIssues(key, result.issues));
+              }
+              payload.value[outKey] = result.value;
+            }
+          }
+        }
+        let unrecognized;
+        for (const key in input) {
+          if (!recordKeys.has(key)) {
+            unrecognized = unrecognized ?? [];
+            unrecognized.push(key);
+          }
+        }
+        if (unrecognized && unrecognized.length > 0) {
+          payload.issues.push({
+            code: "unrecognized_keys",
+            input,
+            inst,
+            keys: unrecognized
+          });
+        }
+      } else {
+        payload.value = {};
+        for (const key of Reflect.ownKeys(input)) {
+          if (key === "__proto__")
+            continue;
+          if (!Object.prototype.propertyIsEnumerable.call(input, key))
+            continue;
+          let keyResult = def.keyType._zod.run({ value: key, issues: [] }, ctx);
+          if (keyResult instanceof Promise) {
+            throw new Error("Async schemas not supported in object keys currently");
+          }
+          const checkNumericKey = typeof key === "string" && number.test(key) && keyResult.issues.length;
+          if (checkNumericKey) {
+            const retryResult = def.keyType._zod.run({ value: Number(key), issues: [] }, ctx);
+            if (retryResult instanceof Promise) {
+              throw new Error("Async schemas not supported in object keys currently");
+            }
+            if (retryResult.issues.length === 0) {
+              keyResult = retryResult;
+            }
+          }
+          if (keyResult.issues.length) {
+            if (def.mode === "loose") {
+              payload.value[key] = input[key];
+            } else {
+              payload.issues.push({
+                code: "invalid_key",
+                origin: "record",
+                issues: keyResult.issues.map((iss) => finalizeIssue(iss, ctx, config3())),
+                input: key,
+                path: [key],
+                inst
+              });
+            }
+            continue;
+          }
+          const result = def.valueType._zod.run({ value: input[key], issues: [] }, ctx);
+          if (result instanceof Promise) {
+            proms.push(result.then((result) => {
+              if (result.issues.length) {
+                payload.issues.push(...prefixIssues(key, result.issues));
+              }
+              payload.value[keyResult.value] = result.value;
+            }));
+          } else {
+            if (result.issues.length) {
+              payload.issues.push(...prefixIssues(key, result.issues));
+            }
+            payload.value[keyResult.value] = result.value;
+          }
+        }
+      }
+      if (proms.length) {
+        return Promise.all(proms).then(() => payload);
+      }
+      return payload;
+    };
+  });
   $ZodEnum = /* @__PURE__ */ $constructor("$ZodEnum", (inst, def) => {
     $ZodType.init(inst, def);
     const values = getEnumValues(def.entries);
@@ -7524,6 +7690,23 @@ var init_schemas = __esm(() => {
       return payload;
     };
   });
+  $ZodLazy = /* @__PURE__ */ $constructor("$ZodLazy", (inst, def) => {
+    $ZodType.init(inst, def);
+    defineLazy(inst._zod, "innerType", () => {
+      const d = def;
+      if (!d._cachedInner)
+        d._cachedInner = def.getter();
+      return d._cachedInner;
+    });
+    defineLazy(inst._zod, "pattern", () => inst._zod.innerType?._zod?.pattern);
+    defineLazy(inst._zod, "propValues", () => inst._zod.innerType?._zod?.propValues);
+    defineLazy(inst._zod, "optin", () => inst._zod.innerType?._zod?.optin ?? undefined);
+    defineLazy(inst._zod, "optout", () => inst._zod.innerType?._zod?.optout ?? undefined);
+    inst._zod.parse = (payload, ctx) => {
+      const inner = inst._zod.innerType;
+      return inner._zod.run(payload, ctx);
+    };
+  });
   $ZodCustom = /* @__PURE__ */ $constructor("$ZodCustom", (inst, def) => {
     $ZodCheck.init(inst, def);
     $ZodType.init(inst, def);
@@ -7992,6 +8175,12 @@ function _coercedBoolean(Class, params) {
     ...normalizeParams(params)
   });
 }
+function _null2(Class, params) {
+  return new Class({
+    type: "null",
+    ...normalizeParams(params)
+  });
+}
 function _unknown(Class) {
   return new Class({
     type: "unknown"
@@ -8601,6 +8790,14 @@ var formatMap, stringProcessor = (schema, ctx, _json, _params) => {
     json.multipleOf = multipleOf;
 }, booleanProcessor = (_schema, _ctx, json, _params) => {
   json.type = "boolean";
+}, nullProcessor = (_schema, ctx, json, _params) => {
+  if (ctx.target === "openapi-3.0") {
+    json.type = "string";
+    json.nullable = true;
+    json.enum = [null];
+  } else {
+    json.type = "null";
+  }
 }, neverProcessor = (_schema, _ctx, json, _params) => {
   json.not = {};
 }, unknownProcessor = (_schema, _ctx, _json, _params) => {}, enumProcessor = (schema, _ctx, json, _params) => {
@@ -8780,6 +8977,41 @@ var formatMap, stringProcessor = (schema, ctx, _json, _params) => {
     json.minItems = minimum;
   if (typeof maximum === "number")
     json.maxItems = maximum;
+}, recordProcessor = (schema, ctx, _json, params) => {
+  const json = _json;
+  const def = schema._zod.def;
+  json.type = "object";
+  const keyType = def.keyType;
+  const keyBag = keyType._zod.bag;
+  const patterns = keyBag?.patterns;
+  if (def.mode === "loose" && patterns && patterns.size > 0) {
+    const valueSchema = process3(def.valueType, ctx, {
+      ...params,
+      path: [...params.path, "patternProperties", "*"]
+    });
+    json.patternProperties = {};
+    for (const pattern of patterns) {
+      json.patternProperties[pattern.source] = valueSchema;
+    }
+  } else {
+    if (ctx.target === "draft-07" || ctx.target === "draft-2020-12") {
+      json.propertyNames = process3(def.keyType, ctx, {
+        ...params,
+        path: [...params.path, "propertyNames"]
+      });
+    }
+    json.additionalProperties = process3(def.valueType, ctx, {
+      ...params,
+      path: [...params.path, "additionalProperties"]
+    });
+  }
+  const keyValues = keyType._zod.values;
+  if (keyValues) {
+    const validKeyValues = [...keyValues].filter((v) => typeof v === "string" || typeof v === "number");
+    if (validKeyValues.length > 0) {
+      json.required = validKeyValues;
+    }
+  }
 }, nullableProcessor = (schema, ctx, json, params) => {
   const def = schema._zod.def;
   const inner = process3(def.innerType, ctx, params);
@@ -8838,6 +9070,11 @@ var formatMap, stringProcessor = (schema, ctx, _json, _params) => {
   process3(def.innerType, ctx, params);
   const seen = ctx.seen.get(schema);
   seen.ref = def.innerType;
+}, lazyProcessor = (schema, ctx, _json, params) => {
+  const innerType = schema._zod.innerType;
+  process3(innerType, ctx, params);
+  const seen = ctx.seen.get(schema);
+  seen.ref = innerType;
 };
 var init_json_schema_processors = __esm(() => {
   init_to_json_schema();
@@ -9018,6 +9255,9 @@ function int(params) {
 function boolean2(params) {
   return _boolean(ZodBoolean, params);
 }
+function _null3(params) {
+  return _null2(ZodNull, params);
+}
 function unknown() {
   return _unknown(ZodUnknown);
 }
@@ -9084,6 +9324,22 @@ function tuple(items, _paramsOrRest, _params) {
     ...normalizeParams(params)
   });
 }
+function record(keyType, valueType, params) {
+  if (!valueType || !valueType._zod) {
+    return new ZodRecord({
+      type: "record",
+      keyType: string2(),
+      valueType: keyType,
+      ...normalizeParams(valueType)
+    });
+  }
+  return new ZodRecord({
+    type: "record",
+    keyType,
+    valueType,
+    ...normalizeParams(params)
+  });
+}
 function _enum(values, params) {
   const entries = Array.isArray(values) ? Object.fromEntries(values.map((v) => [v, v])) : values;
   return new ZodEnum({
@@ -9175,13 +9431,25 @@ function templateLiteral(parts, params) {
     ...normalizeParams(params)
   });
 }
+function lazy(getter) {
+  return new ZodLazy({
+    type: "lazy",
+    getter
+  });
+}
 function refine(fn, _params = {}) {
   return _refine(ZodCustom, fn, _params);
 }
 function superRefine(fn, params) {
   return _superRefine(fn, params);
 }
-var _installedGroups, ZodType, _ZodString, ZodString, ZodStringFormat, ZodEmail, ZodGUID, ZodUUID, ZodURL, ZodEmoji, ZodNanoID, ZodCUID, ZodCUID2, ZodULID, ZodXID, ZodKSUID, ZodIPv4, ZodIPv6, ZodCIDRv4, ZodCIDRv6, ZodBase64, ZodBase64URL, ZodE164, ZodJWT, ZodNumber, ZodNumberFormat, ZodBoolean, ZodUnknown, ZodNever, ZodArray, ZodObject, ZodUnion, ZodDiscriminatedUnion, ZodIntersection, ZodTuple, ZodEnum, ZodLiteral, ZodTransform, ZodOptional, ZodExactOptional, ZodNullable, ZodDefault, ZodPrefault, ZodNonOptional, ZodCatch, ZodPipe, ZodReadonly, ZodTemplateLiteral, ZodCustom;
+function json(params) {
+  const jsonSchema = lazy(() => {
+    return union([string2(params), number2(), boolean2(), _null3(), array(jsonSchema), record(string2(), jsonSchema)]);
+  });
+  return jsonSchema;
+}
+var _installedGroups, ZodType, _ZodString, ZodString, ZodStringFormat, ZodEmail, ZodGUID, ZodUUID, ZodURL, ZodEmoji, ZodNanoID, ZodCUID, ZodCUID2, ZodULID, ZodXID, ZodKSUID, ZodIPv4, ZodIPv6, ZodCIDRv4, ZodCIDRv6, ZodBase64, ZodBase64URL, ZodE164, ZodJWT, ZodNumber, ZodNumberFormat, ZodBoolean, ZodNull, ZodUnknown, ZodNever, ZodArray, ZodObject, ZodUnion, ZodDiscriminatedUnion, ZodIntersection, ZodTuple, ZodRecord, ZodEnum, ZodLiteral, ZodTransform, ZodOptional, ZodExactOptional, ZodNullable, ZodDefault, ZodPrefault, ZodNonOptional, ZodCatch, ZodPipe, ZodReadonly, ZodTemplateLiteral, ZodLazy, ZodCustom;
 var init_schemas2 = __esm(() => {
   init_core2();
   init_core2();
@@ -9554,6 +9822,11 @@ var init_schemas2 = __esm(() => {
     ZodType.init(inst, def);
     inst._zod.processJSONSchema = (ctx, json, params) => booleanProcessor(inst, ctx, json, params);
   });
+  ZodNull = /* @__PURE__ */ $constructor("ZodNull", (inst, def) => {
+    $ZodNull.init(inst, def);
+    ZodType.init(inst, def);
+    inst._zod.processJSONSchema = (ctx, json, params) => nullProcessor(inst, ctx, json, params);
+  });
   ZodUnknown = /* @__PURE__ */ $constructor("ZodUnknown", (inst, def) => {
     $ZodUnknown.init(inst, def);
     ZodType.init(inst, def);
@@ -9660,6 +9933,13 @@ var init_schemas2 = __esm(() => {
       rest
     });
   });
+  ZodRecord = /* @__PURE__ */ $constructor("ZodRecord", (inst, def) => {
+    $ZodRecord.init(inst, def);
+    ZodType.init(inst, def);
+    inst._zod.processJSONSchema = (ctx, json, params) => recordProcessor(inst, ctx, json, params);
+    inst.keyType = def.keyType;
+    inst.valueType = def.valueType;
+  });
   ZodEnum = /* @__PURE__ */ $constructor("ZodEnum", (inst, def) => {
     $ZodEnum.init(inst, def);
     ZodType.init(inst, def);
@@ -9808,6 +10088,12 @@ var init_schemas2 = __esm(() => {
     ZodType.init(inst, def);
     inst._zod.processJSONSchema = (ctx, json, params) => templateLiteralProcessor(inst, ctx, json, params);
   });
+  ZodLazy = /* @__PURE__ */ $constructor("ZodLazy", (inst, def) => {
+    $ZodLazy.init(inst, def);
+    ZodType.init(inst, def);
+    inst._zod.processJSONSchema = (ctx, json, params) => lazyProcessor(inst, ctx, json, params);
+    inst.unwrap = () => inst._zod.def.getter();
+  });
   ZodCustom = /* @__PURE__ */ $constructor("ZodCustom", (inst, def) => {
     $ZodCustom.init(inst, def);
     ZodType.init(inst, def);
@@ -10429,7 +10715,10 @@ var init_admin_artists = __esm(() => {
     path: "/admin/artists/rank",
     summary: "One tick of the similar-artists sweep (artist centroids + top-K edges)",
     tags: ["Admin"]
-  }).input(object({ limit: number3().int().min(1).max(1000).default(50) })).output(object({
+  }).input(object({
+    countRemaining: boolean3().default(false),
+    limit: number3().int().min(1).max(1000).default(50)
+  })).output(object({
     ok: literal(true),
     summary: object({
       centroidsComputed: number2(),
@@ -11144,7 +11433,7 @@ var init_admin_bios = __esm(() => {
 });
 
 // ../../packages/contracts/src/orpc/admin-catalogue.ts
-var CatalogueLensSchema, CapturePriorityReasonSchema, CatalogueMatchSchema, CatalogueTrackItemSchema, CatalogueSummarySchema, listCatalogueTracks, rankCatalogue, recordDemand, clearWrongAudio, requeueUnmatchedCaptures, requeueAnchor, flagWrongAudio, forceCapture, certifyTrack, setTrackDismissed, CaptureVerifyItemSchema, listUnverifiedCaptures, verifyCapture, CrawlPassSchema, CrawlStatusSchema, crawlCatalogue, getCrawlStatus, ANCHOR_CANDIDATE_LIMIT = 100, ANCHOR_ARTIST_LIMIT = 20, ANCHOR_TEXT_MAX = 300, ANCHOR_ISRC_MAX = 64, ANCHOR_ID_MAX = 64, ANCHOR_URL_MAX = 2048, AnchorCandidateSchema, anchorTrack, DEEZER_CANDIDATE_LIMIT = 5, DEEZER_TEXT_MAX = 300, DEEZER_ISRC_MAX = 64, DEEZER_TRACK_ID_MAX = 32, DeezerIsrcCandidateSchema, resolveAnchor, resolveAnchorReview, setAnchorSearch, setAnchorApify, CaptureBudgetStateSchema, getCaptureBudget, setCaptureBudget, SpotifyAnchorBreakerStateSchema, getSpotifyAnchorBreaker, resetSpotifyAnchorBreaker, AppleBreakerStateSchema, resetAppleBreaker, adminCatalogueContract;
+var CatalogueLensSchema, CapturePriorityReasonSchema, CatalogueMatchSchema, CatalogueTrackItemSchema, CatalogueSummarySchema, listCatalogueTracks, rankCatalogue, recordDemand, clearWrongAudio, requeueUnmatchedCaptures, requeueAnchor, flagWrongAudio, forceCapture, certifyTrack, setTrackDismissed, CaptureVerifyItemSchema, listUnverifiedCaptures, verifyCapture, CrawlPassSchema, CrawlPhaseInitializationSchema, CrawlPhaseInputSchema, CrawlPhaseOutputSchema, CrawlStatusSchema, crawlCatalogue, getCrawlStatus, ANCHOR_CANDIDATE_LIMIT = 100, ANCHOR_ARTIST_LIMIT = 20, ANCHOR_TEXT_MAX = 300, ANCHOR_ISRC_MAX = 64, ANCHOR_ID_MAX = 64, ANCHOR_URL_MAX = 2048, AnchorCandidateSchema, anchorTrack, DEEZER_CANDIDATE_LIMIT = 5, DEEZER_TEXT_MAX = 300, DEEZER_ISRC_MAX = 64, DEEZER_TRACK_ID_MAX = 32, DeezerIsrcCandidateSchema, resolveAnchor, resolveAnchorReview, setAnchorSearch, setAnchorApify, CaptureBudgetStateSchema, getCaptureBudget, setCaptureBudget, SpotifyAnchorBreakerStateSchema, getSpotifyAnchorBreaker, resetSpotifyAnchorBreaker, AppleBreakerStateSchema, resetAppleBreaker, adminCatalogueContract;
 var init_admin_catalogue = __esm(() => {
   init_dist3();
   init_zod();
@@ -11365,6 +11654,70 @@ var init_admin_catalogue = __esm(() => {
     tracksSkippedLabelGate: number2().optional(),
     tracksWritten: number2()
   }).meta({ id: "CrawlPass" });
+  CrawlPhaseInitializationSchema = object({
+    artistsRearmed: number2(),
+    releasesRearmed: number2(),
+    seeded: number2(),
+    seedsRearmed: number2()
+  });
+  CrawlPhaseInputSchema = discriminatedUnion("phase", [
+    object({ phase: literal("initialize") }),
+    object({
+      limit: number2().int().min(1).max(2).default(2),
+      maxHop: number2().int().min(0).max(3).default(2),
+      phase: literal("prepare")
+    }),
+    object({ phase: literal("fetch"), preparedToken: string2().max(2 * 1024 * 1024) }),
+    object({
+      commitToken: string2().max(2 * 1024 * 1024),
+      operationId: literal("catalogue.crawl"),
+      operationKey: string2().max(128),
+      phase: literal("commit"),
+      requestDigest: string2().regex(/^[0-9a-f]{64}$/)
+    })
+  ]);
+  CrawlPhaseOutputSchema = discriminatedUnion("phase", [
+    object({
+      initialization: CrawlPhaseInitializationSchema,
+      kind: _enum(["initialized", "unavailable"]),
+      ok: literal(true),
+      phase: literal("initialize")
+    }),
+    object({
+      frontierPending: number2(),
+      initialization: CrawlPhaseInitializationSchema,
+      items: array(object({ nodeId: string2(), preparedToken: string2() })).max(2),
+      kind: _enum(["drained", "prepared", "unavailable"]),
+      ok: literal(true),
+      phase: literal("prepare")
+    }),
+    object({
+      commitToken: string2(),
+      ok: literal(true),
+      operationId: literal("catalogue.crawl"),
+      operationKey: string2(),
+      phase: literal("fetch"),
+      requestDigest: string2()
+    }),
+    object({
+      ok: literal(true),
+      phase: literal("commit"),
+      receipt: object({
+        outcome: _enum([
+          "committed",
+          "conflict",
+          "in-progress",
+          "lookup-failed",
+          "rejected",
+          "safely-retryable"
+        ]),
+        replayed: boolean2(),
+        result: json().optional(),
+        resultIdentity: string2().optional(),
+        state: _enum(["accepted", "committed", "rejected"]).optional()
+      })
+    })
+  ]);
   CrawlStatusSchema = object({
     anchorsPending: number2(),
     catalogueTracks: number2(),
@@ -11390,12 +11743,13 @@ var init_admin_catalogue = __esm(() => {
     summary: "Run one bounded, resumable pass of the catalogue crawler",
     tags: ["Admin"]
   }).input(object({
+    body: CrawlPhaseInputSchema.optional(),
     query: object({
       dryRun: string2().optional(),
       limit: string2().optional(),
       maxHop: string2().optional()
     })
-  })).output(CrawlPassSchema.extend({ ok: literal(true) }));
+  })).output(union([CrawlPassSchema.extend({ ok: literal(true) }), CrawlPhaseOutputSchema]));
   getCrawlStatus = oc.route({
     method: "GET",
     operationId: "getCrawlStatus",
@@ -11953,7 +12307,8 @@ var init_admin_projections = __esm(() => {
     processed: CountSchema,
     scheduled: CountSchema,
     status: ProjectionStatusSchema.optional(),
-    target: ProjectionTargetSchema
+    target: ProjectionTargetSchema,
+    trackSourceMarkersPending: boolean2().optional()
   }));
   setProjectionCutover = oc.route({
     method: "PUT",
@@ -12897,7 +13252,7 @@ var init_admin_operation_receipts = __esm(() => {
 });
 
 // ../../packages/contracts/src/orpc/admin-health.ts
-var HEALTH_SNAPSHOT_PRODUCER_MAX = 64, HEALTH_SNAPSHOT_PRODUCER_PATTERN, ServiceHealthStatusSchema, HealthCheckSchema, recordHealth, adminHealthContract;
+var HEALTH_SNAPSHOT_PRODUCER_MAX = 64, HEALTH_SNAPSHOT_PRODUCER_PATTERN, HEALTH_SNAPSHOT_CHECKS_MAX = 128, HEALTH_SNAPSHOT_SERVICE_MAX = 64, ServiceHealthStatusSchema, HealthCheckSchema, recordHealth, adminHealthContract;
 var init_admin_health = __esm(() => {
   init_dist3();
   init_zod();
@@ -12907,7 +13262,7 @@ var init_admin_health = __esm(() => {
   HealthCheckSchema = object({
     latencyMs: number2().int().nullable(),
     message: string2().nullable(),
-    service: string2().min(1),
+    service: string2().min(1).max(HEALTH_SNAPSHOT_SERVICE_MAX),
     status: ServiceHealthStatusSchema,
     transitioned: boolean2()
   }).meta({ id: "HealthCheck" });
@@ -12919,7 +13274,7 @@ var init_admin_health = __esm(() => {
     tags: ["Admin"]
   }).input(object({
     at: string2().max(64).datetime({ offset: true }),
-    checks: array(HealthCheckSchema),
+    checks: array(HealthCheckSchema).max(HEALTH_SNAPSHOT_CHECKS_MAX),
     operationKey: string2().min(1).max(OPERATION_RECEIPT_KEY_MAX).regex(OPERATION_RECEIPT_KEY_PATTERN).optional(),
     producer: string2().max(HEALTH_SNAPSHOT_PRODUCER_MAX).regex(HEALTH_SNAPSHOT_PRODUCER_PATTERN).optional(),
     requestDigest: string2().regex(OPERATION_RECEIPT_REQUEST_DIGEST_PATTERN).optional()
@@ -12934,24 +13289,34 @@ var init_admin_health = __esm(() => {
 });
 
 // ../../packages/contracts/src/orpc/admin-hub-counts.ts
-var HubCountsTableResultSchema, reconcileHubCounts, adminHubCountsContract;
+var HubCountsTableResultSchema, HubCountsReconcileCursorSchema, reconcileHubCounts, adminHubCountsContract;
 var init_admin_hub_counts = __esm(() => {
   init_dist3();
   init_zod();
   HubCountsTableResultSchema = object({
-    corrected: number2()
+    corrected: number2(),
+    deferred: number2()
   }).meta({ id: "HubCountsTableResult" });
+  HubCountsReconcileCursorSchema = object({
+    afterId: string2().min(1).max(512).nullable(),
+    table: _enum(["labels", "albums", "artists"])
+  }).meta({ id: "HubCountsReconcileCursor" });
   reconcileHubCounts = oc.route({
     method: "POST",
     operationId: "reconcileHubCounts",
     path: "/admin/hub-counts/reconcile",
     summary: "Reconcile the maintained hub counts against truth and report the corrected rows",
     tags: ["Admin"]
-  }).input(object({})).output(object({
+  }).input(object({
+    cursor: HubCountsReconcileCursorSchema.optional(),
+    pageLimit: number2().int().min(1).max(20).optional()
+  })).output(object({
     albums: HubCountsTableResultSchema,
     artists: HubCountsTableResultSchema,
     labels: HubCountsTableResultSchema,
+    next: HubCountsReconcileCursorSchema.nullable(),
     ok: literal(true),
+    pages: number2(),
     tookMs: number2()
   }));
   adminHubCountsContract = {
@@ -14159,7 +14524,7 @@ var init_admin_tokens = __esm(() => {
 });
 
 // ../../packages/contracts/src/orpc/admin-tracks.ts
-var UpdateTrackBodySchema, ObserveTrackBodySchema, ContextTrackBodySchema, NoteTrackBodySchema, NoteEchoSchema, PresignVideoUploadsBodySchema, FinalizeVideoBodySchema, VideoUploadSchema, updateTrack, observeTrack, contextTrack, noteTrack, presignTrackVideoUploads, finalizeTrackVideo, requeueVideo, purgeVideo, PublishTrackResultSchema, getTrackAdmin, listTracksAdmin, TrackWorkKindSchema, TrackWorkScopeSchema, TrackWorkItemSchema, listTrackWork, publishTrack, MixOrderStopSchema, getMixableOrder, adminTracksContract;
+var UpdateTrackBodySchema, ObserveTrackBodySchema, ContextTrackBodySchema, NoteTrackBodySchema, NoteEchoSchema, PresignVideoUploadsBodySchema, FinalizeVideoBodySchema, VideoUploadSchema, updateTrack, CaptureReconciliationKindSchema, CaptureExternalResultSchema, CaptureReceiptCoordinatesSchema, CapturePreparedTrackSchema, CaptureCommittedReceiptResultSchema, CaptureRejectedReceiptResultSchema, prepareTrackCapture, authorizeTrackCapture, commitTrackCapture, observeTrack, contextTrack, noteTrack, presignTrackVideoUploads, finalizeTrackVideo, requeueVideo, purgeVideo, PublishTrackResultSchema, getTrackAdmin, listTracksAdmin, TrackWorkKindSchema, TrackWorkScopeSchema, TrackWorkItemSchema, listTrackWork, publishTrack, MixOrderStopSchema, getMixableOrder, adminTracksContract;
 var init_admin_tracks = __esm(() => {
   init_dist3();
   init_zod();
@@ -14249,6 +14614,157 @@ var init_admin_tracks = __esm(() => {
     ok: literal(true),
     trackId: string2()
   }));
+  CaptureReconciliationKindSchema = _enum([
+    "capture",
+    "youtube-provenance",
+    "youtube-reverdict"
+  ]);
+  CaptureExternalResultSchema = union([
+    discriminatedUnion("outcome", [
+      strictObject({
+        attemptedAt: string2().datetime({ offset: true }),
+        kind: literal("capture"),
+        outcome: _enum(["failed", "unmatched"]),
+        sourceAudioRejected: string2().max(16384).optional()
+      }),
+      strictObject({
+        attemptedAt: string2().datetime({ offset: true }),
+        bytes: number2().int().min(1),
+        captureVerification: _enum(["preview-match", "unverified"]),
+        capturedAt: string2().datetime({ offset: true }),
+        kind: literal("capture"),
+        outcome: literal("done"),
+        sourceAudioKey: string2().min(1).max(1024),
+        sourceAudioRejected: string2().max(16384).optional(),
+        verifiedAt: string2().datetime({ offset: true }),
+        youtubeVideoId: string2().min(1).max(128).optional()
+      })
+    ]),
+    discriminatedUnion("outcome", [
+      strictObject({
+        kind: literal("youtube-provenance"),
+        outcome: literal("none"),
+        verification: _enum(["inconclusive", "no-match"])
+      }),
+      strictObject({
+        kind: literal("youtube-provenance"),
+        outcome: literal("source-found"),
+        sourceVerification: _enum(["soundcloud-archive-match", "soundcloud-preview-match"])
+      }),
+      strictObject({
+        kind: literal("youtube-provenance"),
+        outcome: literal("youtube-found"),
+        verification: _enum(["archive-match", "metadata-match", "preview-match"]),
+        youtubeVideoId: string2().min(1).max(128)
+      })
+    ]),
+    strictObject({ kind: literal("youtube-reverdict"), outcome: literal("reverdict") })
+  ]);
+  CaptureReceiptCoordinatesSchema = strictObject({
+    operationId: literal("track.capture"),
+    operationKey: string2().min(1).max(256).regex(/^[A-Za-z0-9][A-Za-z0-9._~:/-]*$/),
+    requestDigest: string2().regex(/^[0-9a-f]{64}$/)
+  });
+  CapturePreparedTrackSchema = strictObject({
+    analyzedFrom: _enum(["full", "preview"]).optional(),
+    artists: array(string2().max(512)).max(64),
+    bpm: number2().optional(),
+    certified: boolean2(),
+    durationMs: number2().int().min(1).optional(),
+    label: string2().max(1024).optional(),
+    logId: string2().max(64).optional(),
+    sourceAudioFailures: number2().int().min(0).optional(),
+    sourceAudioKey: string2().max(1024).optional(),
+    sourceAudioRejected: string2().max(16384).optional(),
+    title: string2().max(2048),
+    trackId: string2().min(1).max(256)
+  });
+  CaptureCommittedReceiptResultSchema = union([
+    strictObject({
+      applied: literal(true),
+      kind: literal("capture"),
+      outcome: _enum(["done", "failed", "unmatched"])
+    }),
+    strictObject({
+      applied: literal(true),
+      kind: literal("youtube-provenance"),
+      outcome: _enum(["none", "source-found", "youtube-found"])
+    }),
+    strictObject({
+      applied: literal(true),
+      kind: literal("youtube-reverdict"),
+      outcome: literal("reverdict")
+    })
+  ]);
+  CaptureRejectedReceiptResultSchema = strictObject({
+    applied: literal(false),
+    reason: literal("stale")
+  });
+  prepareTrackCapture = oc.route({
+    method: "POST",
+    operationId: "prepareTrackCapture",
+    path: "/admin/tracks/{trackId}/capture/prepare",
+    summary: "Prepare a current capture reconciliation snapshot",
+    tags: ["Admin"]
+  }).input(strictObject({
+    kind: CaptureReconciliationKindSchema,
+    priorSnapshotToken: string2().min(1).max(65536).optional(),
+    trackId: string2().min(1).max(256)
+  })).output(discriminatedUnion("prepared", [
+    strictObject({
+      ok: literal(true),
+      prepared: literal(false),
+      reason: _enum(["ineligible", "not-found", "stale"])
+    }),
+    strictObject({
+      ok: literal(true),
+      prepared: literal(true),
+      snapshotToken: string2().min(1).max(65536),
+      track: CapturePreparedTrackSchema
+    })
+  ]));
+  authorizeTrackCapture = oc.route({
+    method: "POST",
+    operationId: "authorizeTrackCapture",
+    path: "/admin/tracks/{trackId}/capture/authorize",
+    summary: "Authorize a prepared capture result",
+    tags: ["Admin"]
+  }).input(strictObject({
+    result: CaptureExternalResultSchema,
+    snapshotToken: string2().min(1).max(65536),
+    trackId: string2().min(1).max(256)
+  })).output(CaptureReceiptCoordinatesSchema.extend({
+    commitToken: string2().min(1).max(65536),
+    ok: literal(true)
+  }));
+  commitTrackCapture = oc.route({
+    method: "POST",
+    operationId: "commitTrackCapture",
+    path: "/admin/tracks/{trackId}/capture/commit",
+    summary: "Commit a prepared capture result",
+    tags: ["Admin"]
+  }).input(CaptureReceiptCoordinatesSchema.extend({
+    commitToken: string2().min(1).max(65536),
+    trackId: string2().min(1).max(256)
+  })).output(discriminatedUnion("outcome", [
+    strictObject({
+      ok: literal(true),
+      outcome: literal("committed"),
+      replayed: boolean2(),
+      result: CaptureCommittedReceiptResultSchema
+    }),
+    strictObject({
+      ok: literal(true),
+      outcome: literal("rejected"),
+      replayed: boolean2(),
+      result: CaptureRejectedReceiptResultSchema
+    }),
+    strictObject({
+      ok: literal(true),
+      outcome: _enum(["conflict", "in-progress", "safely-retryable"]),
+      replayed: boolean2()
+    })
+  ]));
   observeTrack = oc.route({
     method: "POST",
     operationId: "observeTrack",
@@ -14484,6 +15000,8 @@ var init_admin_tracks = __esm(() => {
     totalCost: number2()
   }));
   adminTracksContract = {
+    authorize_track_capture: authorizeTrackCapture,
+    commit_track_capture: commitTrackCapture,
     context_track: contextTrack,
     finalize_track_video: finalizeTrackVideo,
     get_mixable_order: getMixableOrder,
@@ -14492,6 +15010,7 @@ var init_admin_tracks = __esm(() => {
     list_tracks_admin: listTracksAdmin,
     note_track: noteTrack,
     observe_track: observeTrack,
+    prepare_track_capture: prepareTrackCapture,
     presign_track_video_uploads: presignTrackVideoUploads,
     publish_track: publishTrack,
     purge_video: purgeVideo,
@@ -18033,6 +18552,9 @@ async function crawlCatalogueCommand(limit, maxHop, dryRun) {
   }
   return adminApiPost(`/api/v1/admin/catalogue/crawl?${params.toString()}`);
 }
+async function crawlCataloguePhaseCommand(body) {
+  return adminApiPost("/api/v1/admin/catalogue/crawl", body);
+}
 async function crawlStatusCommand() {
   return adminApiGet("/api/v1/admin/catalogue/crawl");
 }
@@ -18115,7 +18637,10 @@ async function resolveArtistCommand(artistId) {
 }
 async function rankArtistsCommand(options) {
   const limit = options.limit ? Number.parseInt(options.limit, 10) : undefined;
-  const response = await adminApiPost("/api/v1/admin/artists/rank", limit ? { limit } : {});
+  const response = await adminApiPost("/api/v1/admin/artists/rank", {
+    ...limit ? { limit } : {},
+    ...options.countRemaining ? { countRemaining: true } : {}
+  });
   return { summary: response.summary };
 }
 async function backfillArtistImagesCommand(limit, dryRun, cursor) {
@@ -21726,8 +22251,17 @@ JSON field reference:
     }
     console.log(changed ? `Restored ${trackId}. It re-enters the ranking on the next sweep.` : `${trackId} was not dismissed \u2014 nothing to restore.`);
   });
-  catalogue.command("crawl").description("Run one bounded, resumable pass of the catalogue crawler").option("--dry-run", "Report the seed plan and write nothing at all", false).option("--limit <limit>", "Frontier nodes to expand this pass", "10").option("--max-hop <maxHop>", "Graph distance from a seed label (0-3)", "2").option("--json", "Print JSON", false).action(async (options) => {
+  catalogue.command("crawl").description("Run one bounded, resumable pass of the catalogue crawler").option("--dry-run", "Report the seed plan and write nothing at all", false).option("--limit <limit>", "Frontier nodes to expand this pass", "10").option("--max-hop <maxHop>", "Graph distance from a seed label (0-3)", "2").addOption(new Option("--phase-file <path>").hideHelp()).option("--json", "Print JSON", false).action(async (options) => {
     await Promise.resolve().then(() => init_admin_catalogue2());
+    if (options.phaseFile) {
+      if (options.dryRun) {
+        throw new Error("--phase-file cannot be combined with --dry-run");
+      }
+      const body = JSON.parse(readFileSync6(options.phaseFile, "utf8"));
+      const result = await crawlCataloguePhaseCommand(body);
+      printJson(result);
+      return;
+    }
     await runCrawlCatalogue(options, crawlCatalogueCommand);
   });
   catalogue.command("status").description("The crawl frontier's state, the catalogue's size, and the seed set").option("--json", "Print JSON", false).action(async (options) => {
@@ -24034,7 +24568,10 @@ async function runGalaxies(slug, options, commands) {
   }
 }
 async function runArtistsRank(options, rankArtistsCommand) {
-  const { summary } = await rankArtistsCommand({ limit: options.limit });
+  const { summary } = await rankArtistsCommand({
+    countRemaining: !options.json,
+    limit: options.limit
+  });
   if (options.json) {
     printJson({ ok: true, summary });
     return;

package/package.json

@@ -31,5 +31,5 @@
     "url": "git+https://github.com/mauricekleine/fluncle.git"
   },
   "type": "module",
-  "version": "0.233.0"
+  "version": "0.235.0"
 }