fluncle 0.232.0 → 0.234.0

package/bin/fluncle.mjs

@@ -622,7 +622,7 @@ function parseVersion(version) {
 var currentVersion;
 var init_version = __esm(() => {
   init_output();
-  currentVersion = "0.232.0".trim() ? "0.232.0".trim() : "0.1.0";
+  currentVersion = "0.234.0".trim() ? "0.234.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.232.0".trim() ? "0.232.0".trim() : "0.1.0";
+  currentVersion2 = "0.234.0".trim() ? "0.234.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",
@@ -5583,7 +5583,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 +5606,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 +6368,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 +6799,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 +7254,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 +7668,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 +8153,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 +8768,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 +8955,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 +9048,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 +9233,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 +9302,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 +9409,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 +9800,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 +9911,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 +10066,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);
@@ -11144,7 +11408,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 +11629,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 +11718,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",
@@ -11974,6 +12303,78 @@ var init_admin_projections = __esm(() => {
   };
 });
 
+// ../../packages/contracts/src/orpc/admin-vectors.ts
+var VectorServingReasonSchema, ReadinessSchema, VectorServingStatusSchema, VectorServingResponseSchema, getVectorServing, setVectorServing, adminVectorsContract;
+var init_admin_vectors = __esm(() => {
+  init_dist3();
+  init_zod();
+  VectorServingReasonSchema = _enum([
+    "artifact_contract_mismatch",
+    "checkpoint_mismatch",
+    "consumer_contract_mismatch",
+    "consumer_not_active",
+    "consumer_rebuild_incomplete",
+    "consumer_unavailable",
+    "delta_stale",
+    "empty_index",
+    "pending_ack",
+    "producer_backlog",
+    "replica_stale",
+    "sonar_not_ok",
+    "sonar_unavailable",
+    "build_identity_missing",
+    "validation_failed"
+  ]);
+  ReadinessSchema = object({
+    ready: boolean2(),
+    reasons: array(VectorServingReasonSchema)
+  });
+  VectorServingStatusSchema = object({
+    commissioning: ReadinessSchema,
+    enabled: boolean2(),
+    evidence: object({
+      artifactVersion: string2().nullable(),
+      checkpoint: number2().int().nonnegative().nullable(),
+      checkpointedAt: string2().nullable(),
+      commit: string2().nullable(),
+      consumerAppliedThroughSeq: number2().int().nonnegative().nullable(),
+      consumerHeadSeq: number2().int().nonnegative().nullable(),
+      consumerId: string2().nullable(),
+      consumerState: _enum(["active", "inactive", "rebuilding"]).nullable(),
+      deltaAgeSeconds: number2().int().nonnegative().nullable(),
+      deltaBacklog: number2().int().nonnegative().nullable(),
+      pendingAck: boolean2().nullable(),
+      replicaLagSeconds: number2().int().nullable(),
+      tracks: number2().int().nonnegative().nullable(),
+      validation: _enum(["last_attempt_failed", "valid"]).nullable()
+    }),
+    runtime: ReadinessSchema,
+    target: literal("tracks")
+  });
+  VectorServingResponseSchema = object({
+    ok: literal(true),
+    status: VectorServingStatusSchema
+  });
+  getVectorServing = oc.route({
+    method: "GET",
+    operationId: "getVectorServing",
+    path: "/admin/vectors/tracks/serving",
+    summary: "Read track vector-serving readiness",
+    tags: ["Admin"]
+  }).output(VectorServingResponseSchema);
+  setVectorServing = oc.route({
+    method: "PUT",
+    operationId: "setVectorServing",
+    path: "/admin/vectors/tracks/serving",
+    summary: "Enable or disable track vector serving",
+    tags: ["Admin"]
+  }).input(object({ enabled: boolean2() })).output(VectorServingResponseSchema);
+  adminVectorsContract = {
+    get_vector_serving: getVectorServing,
+    set_vector_serving: setVectorServing
+  };
+});
+
 // ../../packages/contracts/src/orpc/admin-reach.ts
 var CollectedPlatformSchema, SkippedPlatformSchema, FailedPlatformSchema, recordPlatformStats, adminReachContract;
 var init_admin_reach = __esm(() => {
@@ -14087,7 +14488,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();
@@ -14177,6 +14578,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",
@@ -14412,6 +14964,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,
@@ -14420,6 +14974,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,
@@ -15768,6 +16323,7 @@ var init_orpc = __esm(() => {
   init_admin_galaxies();
   init_admin_prompts();
   init_admin_projections();
+  init_admin_vectors();
   init_admin_reach();
   init_albums2();
   init_artists2();
@@ -15827,6 +16383,7 @@ var init_orpc = __esm(() => {
   init_admin_artifacts();
   init_admin_operation_receipts();
   init_admin_projections();
+  init_admin_vectors();
   init_admin_artist_rules();
   init_admin_artists();
   init_admin_attention2();
@@ -15892,6 +16449,7 @@ var init_orpc = __esm(() => {
     ...adminGalaxiesContract,
     ...adminPromptsContract,
     ...adminProjectionsContract,
+    ...adminVectorsContract,
     ...adminReachContract,
     ...albumsContract,
     ...artistsContract,
@@ -16085,6 +16643,39 @@ var init_admin_projections2 = __esm(() => {
   init_api();
 });
 
+// src/commands/admin-vectors.ts
+async function getVectorServingCommand(target) {
+  return adminApiGet(`/api/v1/admin/vectors/${target}/serving`);
+}
+async function setVectorServingCommand(input) {
+  return adminApiPut(`/api/v1/admin/vectors/${input.target}/serving`, {
+    enabled: input.enabled
+  });
+}
+function parseVectorTarget(value) {
+  if (value !== "tracks") {
+    throw new Error("target must be tracks");
+  }
+  return value;
+}
+function parseVectorEnabled(value) {
+  if (value !== "true" && value !== "false") {
+    throw new Error("--enabled must be true or false");
+  }
+  return value === "true";
+}
+function vectorServingStatusLines(status) {
+  const reasons = (label, values) => values.length === 0 ? `${label}: ready.` : `${label}: ${values.join(", ")}.`;
+  return [
+    `tracks: ${status.enabled ? "enabled" : "disabled"}.`,
+    reasons("commissioning", status.commissioning.reasons),
+    reasons("runtime", status.runtime.reasons)
+  ];
+}
+var init_admin_vectors2 = __esm(() => {
+  init_api();
+});
+
 // src/commands/admin-artifacts.ts
 function consumerPath(consumerId) {
   return `/api/v1/admin/artifacts/consumers/${encodeURIComponent(consumerId)}`;
@@ -17925,6 +18516,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");
 }
@@ -20870,6 +21464,33 @@ JSON field reference:
     }
     console.log(`${result.target}: cutover ${result.enabled ? "open" : "dark"}.`);
   });
+  const adminVectors = configureCommand(admin.command("vectors").description("Vector-serving readiness and rollback controls"));
+  adminVectors.action(() => {
+    adminVectors.outputHelp();
+  });
+  adminVectors.command("get").description("Read vector-serving commissioning and runtime readiness").argument("<target>", "tracks").option("--json", "Print the complete machine-readable readiness contract", false).action(async (targetValue, options) => {
+    const vectors = await Promise.resolve().then(() => (init_admin_vectors2(), {}));
+    const result = await getVectorServingCommand(parseVectorTarget(targetValue));
+    if (options.json) {
+      printJson(result);
+      return;
+    }
+    console.log(vectorServingStatusLines(result.status).join(`
+`));
+  });
+  adminVectors.command("set").description("Enable a commissioned vector target or disable it unconditionally").argument("<target>", "tracks").requiredOption("--enabled <boolean>", "true enables; false disables unconditionally").option("--json", "Print the stored flag and current readiness as JSON", false).action(async (targetValue, options) => {
+    const vectors = await Promise.resolve().then(() => (init_admin_vectors2(), {}));
+    const result = await setVectorServingCommand({
+      enabled: parseVectorEnabled(options.enabled),
+      target: parseVectorTarget(targetValue)
+    });
+    if (options.json) {
+      printJson(result);
+      return;
+    }
+    console.log(vectorServingStatusLines(result.status).join(`
+`));
+  });
   const adminArtifacts = configureCommand(admin.command("artifacts").description("Versioned derived-artifact change log"));
   adminArtifacts.action(() => {
     adminArtifacts.outputHelp();
@@ -21591,8 +22212,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) => {

package/package.json

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