target-supabase-sdk 0.2.3 → 0.2.4

package/dist/chunks/{word.interface-DLgRobKV.js → word.interface-B_fbVFOW.js}

@@ -1,6 +1,305 @@
-import { B as BaseValidator, e as createTarget, E as validateWithSchema, d as createLogger, A as updateTargetDetails, g as generateResponse, f as deleteTarget, i as getTarget, y as scanTargetList, h as getPossibleTarget, j as getTargetList, o as isOptimisticLockError, c as OPTIMISTIC_LOCK_FAILED_MESSAGE, O as OPTIMISTIC_LOCK_ERROR_CODE, s as logManager } from './create-logger-DyH3mZ8p.js';
+import { b as LOG_PERSIST_LOADER_KEY, G as validateWithSchema, k as getTarget, j as getPossibleTarget, i as generateResponse, E as updateTargetDetails, f as createLogger, g as createTarget, o as isCreateTargetAlreadyExistsError, A as scanTargetList, B as BaseValidator, h as deleteTarget, q as isOptimisticLockError, l as getTargetList, e as OPTIMISTIC_LOCK_FAILED_MESSAGE, O as OPTIMISTIC_LOCK_ERROR_CODE, u as logManager } from './list.api-Ab9v8yOg.js';
 import { z } from 'zod';
 
+/**
+ * Read side of the log-persist pipeline: decode persisted `LogBatch` Lists into
+ * structured batches and flat entries. Pure and defensive — malformed rows are
+ * skipped rather than thrown. Mirrors the write side in `log-persist-flush.ts`.
+ */
+const LANES = new Set(["fast", "medium", "slow"]);
+function asRecord$1(value) {
+    return typeof value === "object" && value !== null ? value : null;
+}
+function asFiniteNumber$1(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function asString(value) {
+    return typeof value === "string" ? value : null;
+}
+/** Parse `ListDetails.meta` (object or legacy JSON string) into typed batch meta, or null. */
+function parseLogBatchMeta(rawMeta) {
+    let source;
+    if (typeof rawMeta === "string") {
+        try {
+            source = asRecord$1(JSON.parse(rawMeta));
+        }
+        catch {
+            return null;
+        }
+    }
+    else {
+        source = asRecord$1(rawMeta);
+    }
+    if (source == null) {
+        return null;
+    }
+    const service = asString(source.service);
+    const processName = asString(source.process);
+    const laneRaw = asString(source.lane);
+    const idempotencyKey = asString(source.idempotencyKey);
+    if (service == null || processName == null || laneRaw == null || !LANES.has(laneRaw) || idempotencyKey == null) {
+        return null;
+    }
+    return {
+        service,
+        process: processName,
+        lane: laneRaw,
+        pid: asFiniteNumber$1(source.pid) ?? 0,
+        count: asFiniteNumber$1(source.count) ?? 0,
+        from: asFiniteNumber$1(source.from),
+        to: asFiniteNumber$1(source.to),
+        flushedAt: asFiniteNumber$1(source.flushedAt) ?? 0,
+        idempotencyKey,
+    };
+}
+/** Structural guard for a persisted {@link LogEntry}. */
+function isLogEntry(value) {
+    const record = asRecord$1(value);
+    return (record != null &&
+        typeof record.timestamp === "number" &&
+        typeof record.level === "string" &&
+        typeof record.message === "string" &&
+        typeof record.topic === "string" &&
+        typeof record.module === "string" &&
+        typeof record.traceId === "string");
+}
+/** Is this List a persisted log batch (by loaderKey)? */
+function isLogBatchList(list) {
+    return list.details?.loaderKey === LOG_PERSIST_LOADER_KEY;
+}
+/**
+ * Decode a `List` row into a {@link DecodedLogBatch}. Returns null when the row
+ * is not a log batch or the meta/items are malformed.
+ */
+function decodeLogBatch(list) {
+    if (!isLogBatchList(list)) {
+        return null;
+    }
+    const meta = parseLogBatchMeta(list.details?.meta);
+    if (meta == null) {
+        return null;
+    }
+    const items = Array.isArray(list.details?.items) ? list.details.items : [];
+    const entries = items.filter(isLogEntry);
+    return {
+        listId: list.id,
+        createdAt: list.created_at,
+        meta,
+        entries,
+    };
+}
+/** Decode many List rows, dropping any that are not valid log batches. */
+function decodeLogBatchList(lists) {
+    const decoded = [];
+    for (const list of lists) {
+        const batch = decodeLogBatch(list);
+        if (batch != null) {
+            decoded.push(batch);
+        }
+    }
+    return decoded;
+}
+/** Flatten one batch into per-entry rows carrying the batch origin fields. */
+function flattenLogBatch(batch) {
+    return batch.entries.map((entry) => ({
+        ...entry,
+        service: batch.meta.service,
+        process: batch.meta.process,
+        lane: batch.meta.lane,
+        pid: batch.meta.pid,
+        batchId: batch.meta.idempotencyKey,
+    }));
+}
+/** Flatten many batches into a single flat entry list. */
+function flattenLogBatches(batches) {
+    const flat = [];
+    for (const batch of batches) {
+        flat.push(...flattenLogBatch(batch));
+    }
+    return flat;
+}
+
+var CategoryExtraction;
+(function (CategoryExtraction) {
+    CategoryExtraction["EXTRACTION"] = "extraction";
+})(CategoryExtraction || (CategoryExtraction = {}));
+
+const targetIdSchema$2 = z.string().trim().min(1);
+const loaderKeySchema = z.string().trim().min(1);
+const postExtractionSchema = z.object({
+    name: z.string().trim().min(1),
+    /** Source Target id — for log analysis this is the producing Task id. */
+    sourceId: targetIdSchema$2,
+    loaderKey: loaderKeySchema,
+    meta: z.unknown().optional(),
+    objects: z.array(z.unknown()).min(1),
+    tagList: z.array(z.string()).optional().default([]),
+    extra: z.string().optional(),
+});
+const getExtractionSchema = z
+    .object({
+    id: targetIdSchema$2.optional(),
+    sourceId: targetIdSchema$2.optional(),
+    loaderKey: loaderKeySchema.optional(),
+})
+    .refine((payload) => {
+    const hasId = payload.id != null && payload.id !== "";
+    const hasSource = payload.sourceId != null && payload.sourceId !== "";
+    if (hasId) {
+        return !hasSource;
+    }
+    return hasSource && payload.loaderKey != null && payload.loaderKey !== "";
+}, { message: "Provide id, or both sourceId and loaderKey" });
+const scanExtractionListSchema = z.object({
+    loaderKey: loaderKeySchema.optional(),
+    sourceId: targetIdSchema$2.optional(),
+    maxRows: z.number().int().min(1).max(500).optional(),
+    ascending: z.boolean().optional(),
+});
+const patchExtractionObjectsSchema = z.object({
+    id: targetIdSchema$2,
+    objects: z.array(z.unknown()).min(1),
+    meta: z.unknown().optional(),
+    expectedRevision: z.number().int().min(0).optional(),
+});
+const extractionCategoryFilter = {
+    field: "category",
+    operator: "eq",
+    value: CategoryExtraction.EXTRACTION,
+};
+function extractionRedundancyFilters(sourceId, loaderKey) {
+    return [
+        extractionCategoryFilter,
+        { field: "value", operator: "eq", value: sourceId },
+        { field: "details->>loaderKey", operator: "eq", value: loaderKey },
+    ];
+}
+function normalizeExtractionMeta(meta, patch) {
+    const base = meta != null && typeof meta === "object" && !Array.isArray(meta)
+        ? { ...meta }
+        : {};
+    if (patch != null && typeof patch === "object" && !Array.isArray(patch)) {
+        Object.assign(base, patch);
+    }
+    const revision = typeof base.revision === "number" && Number.isInteger(base.revision) ? base.revision : 0;
+    base.revision = revision;
+    base.updatedAt = new Date().toISOString();
+    return base;
+}
+/** Create an Extraction row for `(sourceId, loaderKey)`. Idempotent on redundancy key. */
+const postExtraction = validateWithSchema(postExtractionSchema, "postExtractionSchema")(async (payload) => {
+    const logger = createLogger({ module: "postExtraction" });
+    const meta = normalizeExtractionMeta(payload.meta, { revision: 0 });
+    try {
+        return await createTarget({
+            payload,
+            checkRedundancyFilterList: extractionRedundancyFilters(payload.sourceId, payload.loaderKey),
+            createFn: () => ({
+                name: payload.name,
+                value: payload.sourceId,
+                category: CategoryExtraction.EXTRACTION,
+                tagList: payload.tagList,
+                extra: payload.extra,
+                details: {
+                    manifestVersion: 0,
+                    loaderKey: payload.loaderKey,
+                    meta,
+                    objects: payload.objects,
+                },
+            }),
+        });
+    }
+    catch (error) {
+        if (isCreateTargetAlreadyExistsError(error)) {
+            logger.warn("Extraction already exists for source + loaderKey", {
+                topic: "extraction",
+                data: { sourceId: payload.sourceId, loaderKey: payload.loaderKey },
+            });
+            throw error;
+        }
+        throw error;
+    }
+});
+/** Fetch one Extraction by row id, or by `(sourceId, loaderKey)`. */
+const getExtraction = validateWithSchema(getExtractionSchema, "getExtractionSchema")(async (payload) => {
+    if (payload.id != null && payload.id !== "") {
+        const result = await getTarget({
+            id: payload.id,
+            filterList: [extractionCategoryFilter],
+        });
+        return {
+            ...result,
+            data: result.data,
+        };
+    }
+    const result = await getPossibleTarget({
+        filterList: extractionRedundancyFilters(payload.sourceId, payload.loaderKey),
+    });
+    if (result.data == null) {
+        return generateResponse.error("Extraction not found", undefined, "NOT_FOUND");
+    }
+    return {
+        ...result,
+        data: result.data,
+    };
+});
+/** Scan Extraction rows (newest first by default). */
+const scanExtractionList = validateWithSchema(scanExtractionListSchema, "scanExtractionListSchema")(async (payload) => {
+    const filterList = [extractionCategoryFilter];
+    if (payload.loaderKey != null) {
+        filterList.push({ field: "details->>loaderKey", operator: "eq", value: payload.loaderKey });
+    }
+    if (payload.sourceId != null) {
+        filterList.push({ field: "value", operator: "eq", value: payload.sourceId });
+    }
+    return scanTargetList({
+        category: CategoryExtraction.EXTRACTION,
+        filterList,
+        maxRows: payload.maxRows ?? 100,
+        orderBy: { field: "created_at", ascending: payload.ascending ?? false },
+    });
+});
+/** Replace {@link ExtractionDetails.objects} and bump `meta.revision`. */
+const patchExtractionObjects = validateWithSchema(patchExtractionObjectsSchema, "patchExtractionObjectsSchema")(async (payload) => {
+    const optimisticLockFilterList = [];
+    if (payload.expectedRevision != null) {
+        optimisticLockFilterList.push({
+            field: "details->meta->>revision",
+            operator: "eq",
+            value: String(payload.expectedRevision),
+        });
+    }
+    try {
+        const data = await updateTargetDetails({
+            id: payload.id,
+            optimisticLockFilterList,
+            updateFn: (current) => {
+                const currentMeta = current.meta != null && typeof current.meta === "object" && !Array.isArray(current.meta)
+                    ? current.meta
+                    : {};
+                const revision = typeof currentMeta.revision === "number" && Number.isInteger(currentMeta.revision)
+                    ? currentMeta.revision + 1
+                    : 1;
+                return {
+                    ...current,
+                    meta: normalizeExtractionMeta(current.meta, {
+                        ...(payload.meta != null && typeof payload.meta === "object" && !Array.isArray(payload.meta)
+                            ? payload.meta
+                            : {}),
+                        revision,
+                    }),
+                    objects: payload.objects,
+                };
+            },
+        });
+        return generateResponse.success(data);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return generateResponse.error(message, undefined, "PATCH_FAILED");
+    }
+});
+
 var CategoryIdea;
 (function (CategoryIdea) {
     CategoryIdea["OPPORTUNITY"] = "opportunity";
@@ -902,10 +1201,22 @@ var ServiceLifecycleStatus;
     ServiceLifecycleStatus["SUNSET"] = "SUNSET";
 })(ServiceLifecycleStatus || (ServiceLifecycleStatus = {}));
 
+var CategoryConfig;
+(function (CategoryConfig) {
+    CategoryConfig["CONFIG"] = "config";
+})(CategoryConfig || (CategoryConfig = {}));
+/** Globally unique Config key for the declarative system service registry. */
+const TARGET_SYSTEM_REGISTRY_KEY = "target-system-registry";
+
 var CategoryService;
 (function (CategoryService) {
     CategoryService["SERVICE"] = "service";
 })(CategoryService || (CategoryService = {}));
+var ServiceSlotStatus;
+(function (ServiceSlotStatus) {
+    ServiceSlotStatus["EMPTY"] = "EMPTY";
+    ServiceSlotStatus["ACTIVE"] = "ACTIVE";
+})(ServiceSlotStatus || (ServiceSlotStatus = {}));
 var CategoryApi;
 (function (CategoryApi) {
     CategoryApi["API"] = "api";
@@ -918,6 +1229,169 @@ var ApiMethod;
     ApiMethod["DELETE"] = "DELETE";
 })(ApiMethod || (ApiMethod = {}));
 
+const targetIdSchema$1 = z.string().trim().min(1);
+const getConfigSchema = z
+    .object({
+    id: targetIdSchema$1.optional(),
+    value: z.string().trim().min(1).optional(),
+})
+    .refine((payload) => {
+    const hasId = payload.id != null && payload.id !== "";
+    const hasValue = payload.value != null && payload.value !== "";
+    return hasId !== hasValue;
+}, { message: "Provide exactly one of id or value" });
+/** One declarative EMPTY slot entry for seeding the system registry. */
+const systemRegistrySeedSlotSchema = z.object({
+    serviceValue: z.string().trim().min(1),
+});
+const postSystemRegistryConfigSchema = z.object({
+    /** When omitted, {@link DEFAULT_SYSTEM_REGISTRY_SEED_SLOTS} is used. */
+    slots: z.array(systemRegistrySeedSlotSchema).min(1).optional(),
+    tagList: z.array(z.string()).optional().default([]),
+});
+/** Same payload shape as {@link postSystemRegistryConfig} — replaces slots with fresh EMPTY rows. */
+const resetSystemRegistryConfigSchema = postSystemRegistryConfigSchema;
+const DEFAULT_RESET_RETRY_ATTEMPTS = 5;
+const RESET_RETRY_DELAY_MS = 50;
+/** Default one EMPTY slot per known L3 service (override via payload or seed file). */
+const DEFAULT_SYSTEM_REGISTRY_SEED_SLOTS = [
+    { serviceValue: "log-service" },
+    { serviceValue: "watch-service" },
+    { serviceValue: "download-service" },
+    { serviceValue: "storage-service" },
+];
+const configCategoryFilter = {
+    field: "category",
+    operator: "eq",
+    value: CategoryConfig.CONFIG,
+};
+function buildConfigLookupFilters(payload) {
+    const filters = [configCategoryFilter];
+    if (payload.id == null || payload.id === "") {
+        filters.push({ field: "value", operator: "eq", value: payload.value });
+    }
+    return filters;
+}
+/** Build EMPTY {@link ServiceSlot} rows from seed entries (one slot per array item). */
+function buildEmptyServiceSlots(seedSlots) {
+    return seedSlots.map(({ serviceValue }) => ({
+        serviceValue,
+        serviceId: null,
+        status: ServiceSlotStatus.EMPTY,
+    }));
+}
+function parseRegistryRevision$1(rawMeta) {
+    const source = typeof rawMeta === "object" && rawMeta !== null ? rawMeta : null;
+    const revision = source?.revision;
+    return typeof revision === "number" && Number.isFinite(revision) ? revision : 0;
+}
+function lockOnRegistryRevision$1(revision) {
+    return [{ field: "details->meta->>revision", operator: "eq", value: String(revision) }];
+}
+function sleep$2(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+/** Build `ConfigDetails` for the globally unique system registry row. */
+function buildSystemRegistryConfigDetails(slots) {
+    return {
+        manifestVersion: 0,
+        loaderKey: TARGET_SYSTEM_REGISTRY_KEY,
+        meta: { revision: 0 },
+        objects: [...slots],
+    };
+}
+/** Fetch a Config by id or by {@link Config.value} key (`category=config`). */
+const getConfig = validateWithSchema(getConfigSchema, "getConfigSchema")(async (payload) => {
+    const filterList = buildConfigLookupFilters(payload);
+    if (payload.id != null && payload.id !== "") {
+        const result = await getTarget({
+            id: payload.id,
+            filterList,
+        });
+        return {
+            ...result,
+            data: result.data,
+        };
+    }
+    const result = await getPossibleTarget({
+        filterList,
+    });
+    if (result.data == null) {
+        return {
+            ...result,
+            data: undefined,
+        };
+    }
+    return {
+        ...result,
+        data: result.data,
+    };
+});
+/**
+ * Insert the globally unique system registry Config (`category=config`,
+ * `value=target-system-registry`). Rejects duplicates via `checkRedundancyFilterList`.
+ */
+const postSystemRegistryConfig = validateWithSchema(postSystemRegistryConfigSchema, "postSystemRegistryConfigSchema")(async ({ slots, tagList }) => {
+    const seedSlots = [...(slots ?? DEFAULT_SYSTEM_REGISTRY_SEED_SLOTS)];
+    const serviceSlots = buildEmptyServiceSlots(seedSlots);
+    const details = buildSystemRegistryConfigDetails(serviceSlots);
+    return createTarget({
+        payload: { slots: seedSlots, tagList },
+        checkRedundancyFilterList: [
+            configCategoryFilter,
+            { field: "value", operator: "eq", value: TARGET_SYSTEM_REGISTRY_KEY },
+        ],
+        createFn: () => ({
+            name: TARGET_SYSTEM_REGISTRY_KEY,
+            value: TARGET_SYSTEM_REGISTRY_KEY,
+            category: CategoryConfig.CONFIG,
+            tagList,
+            details,
+        }),
+    });
+});
+/**
+ * Replace the system registry slot layout with fresh EMPTY rows.
+ * Creates the row when missing (same as {@link postSystemRegistryConfig}).
+ * Clears ACTIVE slot bindings — use for dev recovery after crashes or layout changes.
+ */
+const resetSystemRegistryConfig = validateWithSchema(resetSystemRegistryConfigSchema, "resetSystemRegistryConfigSchema")(async ({ slots, tagList }) => {
+    const seedSlots = [...(slots ?? DEFAULT_SYSTEM_REGISTRY_SEED_SLOTS)];
+    const serviceSlots = buildEmptyServiceSlots(seedSlots);
+    const existing = await getConfig({ value: TARGET_SYSTEM_REGISTRY_KEY });
+    if (existing.data == null) {
+        return postSystemRegistryConfig({ slots: seedSlots, tagList });
+    }
+    const configId = existing.data.id;
+    for (let attempt = 1; attempt <= DEFAULT_RESET_RETRY_ATTEMPTS; attempt += 1) {
+        try {
+            const fresh = await getConfig({ id: configId });
+            if (fresh.data == null) {
+                throw new Error(`System registry config disappeared during reset (id=${configId})`);
+            }
+            const revision = parseRegistryRevision$1(fresh.data.details.meta);
+            const updated = await updateTargetDetails({
+                id: configId,
+                optimisticLockFilterList: lockOnRegistryRevision$1(revision),
+                updateFn: (details) => ({
+                    ...details,
+                    meta: { revision: revision + 1 },
+                    objects: serviceSlots,
+                }),
+            });
+            return generateResponse.success(updated);
+        }
+        catch (error) {
+            if (isOptimisticLockError(error) && attempt < DEFAULT_RESET_RETRY_ATTEMPTS) {
+                await sleep$2(RESET_RETRY_DELAY_MS * attempt);
+                continue;
+            }
+            throw error;
+        }
+    }
+    throw new Error("[resetSystemRegistryConfig] Optimistic lock retries exhausted");
+});
+
 const targetIdSchema = z.string().trim().min(1);
 const enumMemberSchema = z.object({
     key: z.string().trim().min(1),
@@ -987,11 +1461,21 @@ const apiDetailsSchema = z.object({
     manifestVersion: z.number().int().nonnegative(),
     lifecycle: serviceLifecycleSchema,
 });
+const serviceNodeSnapshotSchema = z.object({
+    nodeId: z.string().trim().min(1),
+    status: z.nativeEnum(NodeStatus),
+    lastHeartBeat: z.number().int().nonnegative(),
+});
+const serviceRuntimeSchema = z.object({
+    lastHeartBeat: z.number().int().nonnegative(),
+    nodes: z.array(serviceNodeSnapshotSchema).default([]),
+});
 const serviceDetailsSchema = z.object({
     manifestVersion: z.number().int().nonnegative(),
     apiKeys: z.array(z.string().trim().min(1)),
     dependencies: z.array(z.string().trim().min(1)).default([]),
     lifecycle: serviceLifecycleSchema,
+    runtime: serviceRuntimeSchema.optional(),
 });
 const postApiSchema = z.object({
     name: z.string().trim().min(1),
@@ -1039,7 +1523,7 @@ const serviceCategoryFilter = {
     operator: "eq",
     value: CategoryService.SERVICE,
 };
-const SERVICE_LIFECYCLE_STATUS_FIELD$1 = "details->lifecycle->>status";
+const SERVICE_LIFECYCLE_STATUS_FIELD = "details->lifecycle->>status";
 function buildServiceLookupFilters(payload) {
     const filters = [serviceCategoryFilter];
     if (payload.id != null && payload.id !== "") ;
@@ -1048,7 +1532,7 @@ function buildServiceLookupFilters(payload) {
     }
     if (payload.lifecycleStatus != null) {
         filters.push({
-            field: SERVICE_LIFECYCLE_STATUS_FIELD$1,
+            field: SERVICE_LIFECYCLE_STATUS_FIELD,
             operator: "eq",
             value: payload.lifecycleStatus,
         });
@@ -1137,125 +1621,563 @@ const postService = validateWithSchema(postServiceSchema, "postServiceSchema")(a
     });
 });
 
-const DISCOVER_LIFECYCLE_STATUS = ServiceLifecycleStatus.ACTIVE;
-const SERVICE_LIFECYCLE_STATUS_FIELD = "details->lifecycle->>status";
-async function lookupServicePrimary(value) {
-    const response = await getService({ value, lifecycleStatus: DISCOVER_LIFECYCLE_STATUS });
+/**
+ * System registry — declarative service capacity (`target-system-registry` Config)
+ * and startup/shutdown slot claims (`registerService` / `unregisterService`).
+ *
+ * Data planes:
+ *   - Config `details.objects` — {@link ServiceSlot} desired layout (EMPTY / ACTIVE)
+ *   - Service rows — runtime instances; guard maintains {@link ServiceDetails.runtime}
+ *   - Slot release: graceful shutdown via {@link unregisterService}; monitor (later)
+ *     for crashed / ungraceful exits (stale `Service.details.runtime`)
+ */
+const LOG_TOPIC_REGISTRY = "service-registry";
+const DEFAULT_REGISTER_RETRY_ATTEMPTS = 5;
+class ServiceRegistryError extends Error {
+    code;
+    constructor(message, code) {
+        super(message);
+        this.code = code;
+        this.name = "ServiceRegistryError";
+    }
+}
+function asRecord(value) {
+    return typeof value === "object" && value !== null ? value : null;
+}
+function asFiniteNumber(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function isServiceSlotStatus(value) {
+    return value === ServiceSlotStatus.EMPTY || value === ServiceSlotStatus.ACTIVE;
+}
+/** Defensive decode of one {@link ServiceSlot} from Config `details.objects`. */
+function parseServiceSlot(value) {
+    const source = asRecord(value);
+    if (source == null) {
+        return null;
+    }
+    const serviceValue = typeof source.serviceValue === "string" ? source.serviceValue : null;
+    const status = source.status;
+    if (serviceValue == null || !isServiceSlotStatus(status)) {
+        return null;
+    }
+    let serviceId = null;
+    if (source.serviceId != null) {
+        if (typeof source.serviceId !== "string" || source.serviceId === "") {
+            return null;
+        }
+        serviceId = source.serviceId;
+    }
+    if (status === ServiceSlotStatus.EMPTY) {
+        serviceId = null;
+    }
+    else if (serviceId == null) {
+        return null;
+    }
+    return { serviceValue, serviceId, status };
+}
+function parseServiceSlots(config) {
+    const slots = [];
+    for (const object of config.details.objects) {
+        const slot = parseServiceSlot(object);
+        if (slot != null) {
+            slots.push(slot);
+        }
+    }
+    return slots;
+}
+/** Parse `details.meta.revision` from the system registry Config (defaults to 0). */
+function parseRegistryRevision(rawMeta) {
+    const source = asRecord(rawMeta);
+    const revision = asFiniteNumber(source?.revision);
+    return revision ?? 0;
+}
+function nextRegistryMeta(nextRevision) {
+    return { revision: nextRevision };
+}
+function lockOnRegistryRevision(revision) {
+    return [{ field: "details->meta->>revision", operator: "eq", value: String(revision) }];
+}
+function sleep$1(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function loadSystemRegistryConfig() {
+    const response = await getConfig({ value: TARGET_SYSTEM_REGISTRY_KEY });
+    if (response.data == null) {
+        throw new ServiceRegistryError(`System registry config not found (value=${TARGET_SYSTEM_REGISTRY_KEY})`, "REGISTRY_CONFIG_NOT_FOUND");
+    }
+    return response.data;
+}
+async function resolveServiceById(serviceId) {
+    const response = await getService({ id: serviceId });
     return response.data ?? null;
 }
-async function lookupServiceByScan(value) {
-    const { data } = await scanTargetList({
-        category: CategoryService.SERVICE,
-        orderBy: { field: "value", ascending: true },
-        maxRows: 1,
-        filterList: [
-            { field: "value", operator: "eq", value },
-            {
-                field: SERVICE_LIFECYCLE_STATUS_FIELD,
-                operator: "eq",
-                value: DISCOVER_LIFECYCLE_STATUS,
-            },
-        ],
+/**
+ * Load the global system registry Config and resolve each ACTIVE slot's Service row.
+ * Read-only — does not mutate slots or heartbeats.
+ */
+async function getTargetSystemRegistry() {
+    const config = await loadSystemRegistryConfig();
+    const slots = parseServiceSlots(config);
+    const views = await Promise.all(slots.map(async (slot) => {
+        if (slot.serviceId == null) {
+            return { slot, service: null };
+        }
+        const service = await resolveServiceById(slot.serviceId);
+        return { slot, service };
+    }));
+    return { config, slots: views };
+}
+function findFirstEmptySlot(slots, serviceValue) {
+    return slots.findIndex((slot) => slot.serviceValue === serviceValue && slot.status === ServiceSlotStatus.EMPTY);
+}
+function countSlotsForValue(slots, serviceValue) {
+    let declared = 0;
+    let active = 0;
+    let empty = 0;
+    for (const slot of slots) {
+        if (slot.serviceValue !== serviceValue) {
+            continue;
+        }
+        declared++;
+        if (slot.status === ServiceSlotStatus.ACTIVE) {
+            active++;
+        }
+        else if (slot.status === ServiceSlotStatus.EMPTY) {
+            empty++;
+        }
+    }
+    return { declared, active, empty };
+}
+/**
+ * Preflight before `postService` — fail fast when registry capacity is full.
+ * Prevents orphan Service rows and child process spawn when no slot is available.
+ */
+async function assertRegistrySlotAvailable(serviceValue) {
+    const config = await loadSystemRegistryConfig();
+    const slots = parseServiceSlots(config);
+    const counts = countSlotsForValue(slots, serviceValue);
+    if (counts.declared === 0) {
+        throw new ServiceRegistryError(`Service ${serviceValue} is not declared in system registry config`, "SERVICE_NOT_DECLARED");
+    }
+    if (counts.empty === 0) {
+        throw new ServiceRegistryError(`No EMPTY slot for ${serviceValue} — declared=${counts.declared}, active=${counts.active}. Refusing startup.`, "SERVICE_SLOTS_FULL");
+    }
+}
+/**
+ * Runtime guard: this process's Service instance must still own an ACTIVE registry slot.
+ * Supports N>1 replicas — checks whether `serviceId` appears in any ACTIVE slot for
+ * `serviceValue`, not merely the first ACTIVE slot.
+ */
+async function assertRegistrySlotOwner(input) {
+    const config = await loadSystemRegistryConfig();
+    const slots = parseServiceSlots(config);
+    const ownsSlot = slots.some((slot) => slot.serviceValue === input.serviceValue &&
+        slot.status === ServiceSlotStatus.ACTIVE &&
+        slot.serviceId === input.serviceId);
+    if (ownsSlot) {
+        return;
+    }
+    const activeId = slots.find((slot) => slot.serviceValue === input.serviceValue &&
+        slot.status === ServiceSlotStatus.ACTIVE &&
+        slot.serviceId != null)?.serviceId;
+    throw new ServiceRegistryError(`Registry slot for ${input.serviceValue} is not owned by ${input.serviceId} (active=${activeId ?? "none"})`, "REGISTRY_SLOT_LOST");
+}
+function isServiceValueDeclared(slots, serviceValue) {
+    return slots.some((slot) => slot.serviceValue === serviceValue);
+}
+function claimSlot(slots, slotIndex, serviceId) {
+    const next = [...slots];
+    next[slotIndex] = {
+        ...next[slotIndex],
+        serviceId,
+        status: ServiceSlotStatus.ACTIVE,
+    };
+    return next;
+}
+async function persistSlotClaim(params) {
+    const { configId, revision, slots } = params;
+    await updateTargetDetails({
+        id: configId,
+        optimisticLockFilterList: lockOnRegistryRevision(revision),
+        updateFn: (details) => ({
+            ...details,
+            meta: nextRegistryMeta(revision + 1),
+            objects: slots,
+        }),
     });
-    return data?.[0] ?? null;
 }
-async function resolveDiscoverFailureReason(value) {
-    const response = await getService({ value });
-    if (response.data == null) {
-        return "not-found";
+function releaseOwnedSlot(slots, serviceId) {
+    const slotIndex = slots.findIndex((slot) => slot.serviceId === serviceId && slot.status === ServiceSlotStatus.ACTIVE);
+    if (slotIndex < 0) {
+        return null;
     }
-    return "not-available";
+    const next = [...slots];
+    next[slotIndex] = {
+        ...next[slotIndex],
+        serviceId: null,
+        status: ServiceSlotStatus.EMPTY,
+    };
+    return next;
 }
 /**
- * Discover a single service by {@link Service.value}.
- * Only returns services with `lifecycle.status === ACTIVE` (filtered at query time).
+ * Claim one EMPTY slot for a running Service instance (`EMPTY → ACTIVE` only).
  *
- * Lookup: primary `getService` → fallback `scanTargetList` by value.
+ * - Each startup should `postService` a **new** instance row; do not reuse prior Service ids.
+ * - Declared capacity = count of {@link ServiceSlot} rows sharing `service.value`
+ * - No idempotent skip — if all slots are ACTIVE (e.g. crashed prior instance), throws
+ *   `SERVICE_SLOTS_FULL` until monitor/ops releases the slot
+ * - Does not write heartbeats; guard maintains {@link ServiceDetails.runtime}
+ * - Graceful release: {@link unregisterService}; crash recovery: future monitor
  */
-async function discoverService(input) {
-    const value = input.value.trim();
+async function registerService(input) {
+    const { service } = input;
+    const serviceValue = service.value;
+    const maxAttempts = input.maxAttempts ?? DEFAULT_REGISTER_RETRY_ATTEMPTS;
     const logger = createLogger({
-        module: "discoverService",
+        module: "registerService",
         traceId: input.traceId,
-        labels: { serviceValue: value },
+        labels: { serviceValue, serviceId: service.id },
+    });
+    logger.info("开始认领系统 registry 槽位", {
+        topic: LOG_TOPIC_REGISTRY,
+        data: { serviceValue, serviceId: service.id },
     });
-    if (value === "") {
-        const message = "discoverService: value must not be empty";
-        logger.warn(message, { topic: "service", data: { value: input.value } });
-        return generateResponse.error(message, undefined, "SERVICE_VALUE_REQUIRED");
+    for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+        try {
+            const config = await loadSystemRegistryConfig();
+            const revision = parseRegistryRevision(config.details.meta);
+            const slots = parseServiceSlots(config);
+            if (!isServiceValueDeclared(slots, serviceValue)) {
+                throw new ServiceRegistryError(`Service ${serviceValue} is not declared in system registry config`, "SERVICE_NOT_DECLARED");
+            }
+            const emptyIndex = findFirstEmptySlot(slots, serviceValue);
+            if (emptyIndex < 0) {
+                throw new ServiceRegistryError(`No EMPTY slot for ${serviceValue} — declared capacity is full`, "SERVICE_SLOTS_FULL");
+            }
+            const nextSlots = claimSlot(slots, emptyIndex, service.id);
+            await persistSlotClaim({
+                configId: config.id,
+                revision,
+                slots: nextSlots,
+            });
+            logger.info("槽位认领成功", {
+                topic: LOG_TOPIC_REGISTRY,
+                data: {
+                    serviceValue,
+                    serviceId: service.id,
+                    slotIndex: emptyIndex,
+                    attempt,
+                    revision: revision + 1,
+                },
+            });
+            return;
+        }
+        catch (error) {
+            if (error instanceof ServiceRegistryError) {
+                logger.error("槽位认领被拒绝", {
+                    topic: LOG_TOPIC_REGISTRY,
+                    data: { serviceValue, serviceId: service.id, code: error.code, message: error.message },
+                });
+                throw error;
+            }
+            if (isOptimisticLockError(error) && attempt < maxAttempts) {
+                logger.warn("registry 乐观锁冲突，重试", {
+                    topic: LOG_TOPIC_REGISTRY,
+                    data: { serviceValue, serviceId: service.id, attempt, maxAttempts },
+                });
+                await sleep$1(50 * attempt);
+                continue;
+            }
+            const message = error instanceof Error ? error.message : String(error);
+            logger.error("槽位认领失败", {
+                topic: LOG_TOPIC_REGISTRY,
+                data: { serviceValue, serviceId: service.id, attempt, message },
+            });
+            throw new ServiceRegistryError(message, "REGISTRY_UPDATE_FAILED");
+        }
     }
-    try {
-        logger.info("开始发现服务", {
-            topic: "service",
-            data: { value, lifecycleStatus: DISCOVER_LIFECYCLE_STATUS },
-        });
-        let service = await lookupServicePrimary(value);
-        let source = "primary";
-        if (service == null) {
-            logger.warn("主路径未命中，尝试 catalog 扫描回退", {
-                topic: "service",
-                data: { value, step: "scan-fallback", lifecycleStatus: DISCOVER_LIFECYCLE_STATUS },
+    throw new ServiceRegistryError(`Failed to register ${serviceValue} after ${maxAttempts} attempts`, "REGISTRY_UPDATE_FAILED");
+}
+/** Resolve the ACTIVE registry slot id for a declared `serviceValue`. */
+async function resolveActiveRegistryServiceId(serviceValue) {
+    const registry = await getTargetSystemRegistry();
+    for (const { slot } of registry.slots) {
+        if (slot.serviceValue === serviceValue && slot.status === ServiceSlotStatus.ACTIVE && slot.serviceId != null) {
+            return slot.serviceId;
+        }
+    }
+    return null;
+}
+function nodeToServiceNodeSnapshot(node) {
+    return {
+        nodeId: node.id,
+        status: node.details.status,
+        lastHeartBeat: node.details.lastHeartBeat,
+    };
+}
+/** Roll up Node liveness into `Service.details.runtime` (service guard only). */
+async function patchServiceRuntime(input) {
+    const serviceId = input.serviceId ?? (await resolveActiveRegistryServiceId(input.serviceValue));
+    if (serviceId == null) {
+        return;
+    }
+    const nodes = input.nodes.map(nodeToServiceNodeSnapshot);
+    await updateTargetDetails({
+        id: serviceId,
+        updateFn: (details) => ({
+            ...details,
+            runtime: {
+                lastHeartBeat: input.lastHeartBeat,
+                nodes,
+            },
+        }),
+    });
+}
+/**
+ * Claim a registry slot at L3 startup — propagates {@link ServiceRegistryError} (e.g. `SERVICE_SLOTS_FULL`).
+ */
+async function registerServiceAtStartup(input) {
+    await registerService(input);
+}
+/**
+ * Release the ACTIVE slot owned by this Service instance (`ACTIVE → EMPTY` only).
+ *
+ * - Idempotent when no ACTIVE slot is bound to `service.id`
+ * - Does not mutate the Service row or `details.runtime`
+ * - Does not release slots owned by other instances
+ */
+async function unregisterService(input) {
+    const { service } = input;
+    const serviceValue = service.value;
+    const maxAttempts = input.maxAttempts ?? DEFAULT_REGISTER_RETRY_ATTEMPTS;
+    const logger = createLogger({
+        module: "unregisterService",
+        traceId: input.traceId,
+        labels: { serviceValue, serviceId: service.id },
+    });
+    logger.info("开始释放系统 registry 槽位", {
+        topic: LOG_TOPIC_REGISTRY,
+        data: { serviceValue, serviceId: service.id },
+    });
+    for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+        try {
+            const config = await loadSystemRegistryConfig();
+            const revision = parseRegistryRevision(config.details.meta);
+            const slots = parseServiceSlots(config);
+            const nextSlots = releaseOwnedSlot(slots, service.id);
+            if (nextSlots == null) {
+                logger.info("无绑定槽位，跳过释放", {
+                    topic: LOG_TOPIC_REGISTRY,
+                    data: { serviceValue, serviceId: service.id, attempt },
+                });
+                return;
+            }
+            await persistSlotClaim({
+                configId: config.id,
+                revision,
+                slots: nextSlots,
+            });
+            logger.info("槽位释放成功", {
+                topic: LOG_TOPIC_REGISTRY,
+                data: {
+                    serviceValue,
+                    serviceId: service.id,
+                    attempt,
+                    revision: revision + 1,
+                },
             });
-            service = await lookupServiceByScan(value);
-            source = "scan";
+            return;
         }
-        if (service == null) {
-            const reason = await resolveDiscoverFailureReason(value);
-            if (reason === "not-available") {
-                const message = `Service ${value} is not available (lifecycle is not ACTIVE)`;
-                logger.warn("服务已注册但不可用", {
-                    topic: "service",
-                    data: { value, step: "not-available", lifecycleStatus: DISCOVER_LIFECYCLE_STATUS },
+        catch (error) {
+            if (error instanceof ServiceRegistryError) {
+                logger.error("槽位释放被拒绝", {
+                    topic: LOG_TOPIC_REGISTRY,
+                    data: { serviceValue, serviceId: service.id, code: error.code, message: error.message },
+                });
+                throw error;
+            }
+            if (isOptimisticLockError(error) && attempt < maxAttempts) {
+                logger.warn("registry 乐观锁冲突，重试", {
+                    topic: LOG_TOPIC_REGISTRY,
+                    data: { serviceValue, serviceId: service.id, attempt, maxAttempts },
                 });
-                return generateResponse.error(message, undefined, "SERVICE_NOT_AVAILABLE");
+                await sleep$1(50 * attempt);
+                continue;
             }
-            const message = `Service not found: ${value}`;
-            logger.error("服务未发现", {
-                topic: "service",
-                data: { value, step: "not-found", tried: ["primary", "scan"] },
+            const message = error instanceof Error ? error.message : String(error);
+            logger.error("槽位释放失败", {
+                topic: LOG_TOPIC_REGISTRY,
+                data: { serviceValue, serviceId: service.id, attempt, message },
             });
-            return generateResponse.error(message, undefined, "SERVICE_NOT_FOUND");
+            throw new ServiceRegistryError(message, "REGISTRY_UPDATE_FAILED");
         }
-        logger.info("服务发现成功", {
-            topic: "service",
+    }
+    throw new ServiceRegistryError(`Failed to unregister ${serviceValue} after ${maxAttempts} attempts`, "REGISTRY_UPDATE_FAILED");
+}
+/**
+ * Best-effort slot release for process shutdown — never throws.
+ */
+async function unregisterServiceAtShutdown(input) {
+    const logger = createLogger({
+        module: "unregisterServiceAtShutdown",
+        traceId: input.traceId,
+        labels: { serviceValue: input.service.value, serviceId: input.service.id },
+    });
+    try {
+        await unregisterService(input);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        const code = error instanceof ServiceRegistryError ? error.code : undefined;
+        logger.warn("shutdown 释放 registry 槽位失败（best-effort）", {
+            topic: LOG_TOPIC_REGISTRY,
             data: {
-                value,
-                source,
-                serviceId: service.id,
-                lifecycleStatus: service.details.lifecycle.status,
-                apiKeyCount: service.details.apiKeys.length,
-                dependencyCount: service.details.dependencies.length,
+                serviceValue: input.service.value,
+                serviceId: input.service.id,
+                code,
+                message,
             },
         });
-        return generateResponse.success(service);
+    }
+}
+
+const LOG_TOPIC = "service-registry-lifecycle";
+const EMPTY_REGISTRY_SLOT_RUNTIME_STATE = {
+    serviceId: null,
+    serviceValue: null,
+    slotOwned: null,
+    lastSlotCheckAt: null,
+    lastSlotCheckError: null,
+};
+function createClaimedRegistrySlotRuntimeState(service) {
+    return {
+        serviceId: service.id,
+        serviceValue: service.value,
+        slotOwned: true,
+        lastSlotCheckAt: null,
+        lastSlotCheckError: null,
+    };
+}
+/**
+ * Preflight → create Service instance → claim registry slot.
+ * On register failure after `createInstance`, deletes the orphan Service row.
+ */
+async function claimServiceRegistrySlot(input) {
+    const logger = createLogger({
+        module: "claimServiceRegistrySlot",
+        traceId: input.traceId,
+        labels: { serviceValue: input.serviceValue },
+    });
+    await assertRegistrySlotAvailable(input.serviceValue);
+    const service = await input.createInstance();
+    let registered = false;
+    try {
+        await registerServiceAtStartup({ service, traceId: input.traceId });
+        registered = true;
     }
     catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        logger.error("服务发现失败", {
-            topic: "service",
-            data: { value, message },
-        });
-        let service = null;
-        try {
-            service = await lookupServiceByScan(value);
-        }
-        catch (fallbackError) {
-            const fallbackMessage = fallbackError instanceof Error ? fallbackError.message : String(fallbackError);
-            logger.error("扫描回退失败", {
-                topic: "service",
-                data: { value, message: fallbackMessage },
+        await deleteTarget({ id: service.id }).catch((deleteError) => {
+            const message = deleteError instanceof Error ? deleteError.message : String(deleteError);
+            logger.warn("Failed to delete orphan Service row after register failure", {
+                topic: LOG_TOPIC,
+                data: { serviceId: service.id, message },
             });
-            return generateResponse.error(message, undefined, "SERVICE_DISCOVER_FAILED");
-        }
-        if (service != null) {
-            logger.warn("主路径异常后扫描回退成功", {
-                topic: "service",
-                data: { value, serviceId: service.id, primaryError: message },
-            });
-            return generateResponse.success(service);
+        });
+        throw error;
+    }
+    logger.info("registry slot claimed", {
+        topic: LOG_TOPIC,
+        data: { serviceValue: service.value, serviceId: service.id, registered },
+    });
+    return {
+        service,
+        release: async () => {
+            await unregisterServiceAtShutdown({ service, traceId: input.traceId });
+        },
+        abandon: async () => {
+            await deleteTarget({ id: service.id }).catch(() => undefined);
+        },
+    };
+}
+/**
+ * Runtime guard step for service supervisor loops.
+ * Transient read failures soft-fail; confirmed slot loss returns `shouldShutdown: true`.
+ */
+async function runRegistrySlotGuardCheck(input) {
+    try {
+        await assertRegistrySlotOwner(input);
+        return { slotOwned: true, shouldShutdown: false };
+    }
+    catch (error) {
+        if (error instanceof ServiceRegistryError && error.code === "REGISTRY_SLOT_LOST") {
+            return {
+                slotOwned: false,
+                shouldShutdown: true,
+                error: error.message,
+            };
         }
-        return generateResponse.error(message, undefined, "SERVICE_DISCOVER_FAILED");
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+            slotOwned: null,
+            shouldShutdown: false,
+            error: message,
+        };
+    }
+}
+function registrySlotRuntimePatchFromGuardResult(result, checkedAt) {
+    return {
+        slotOwned: result.slotOwned,
+        lastSlotCheckAt: checkedAt,
+        lastSlotCheckError: result.error ?? null,
+    };
+}
+
+function formatLocalDateYmd(date = new Date()) {
+    const year = date.getFullYear();
+    const month = String(date.getMonth() + 1).padStart(2, "0");
+    const day = String(date.getDate()).padStart(2, "0");
+    return `${year}-${month}-${day}`;
+}
+/** Default ACTIVE lifecycle for a newly posted Service instance row. */
+function createActiveServiceLifecycle(activeSince) {
+    return {
+        status: ServiceLifecycleStatus.ACTIVE,
+        activeSince: activeSince ?? formatLocalDateYmd(),
+        deprecatedAt: null,
+        sunsetAt: null,
+    };
+}
+/** Standard L3 Service `details` — empty apiKeys, manifest v0, ACTIVE lifecycle. */
+function defaultL3ServiceDetails(options) {
+    return {
+        manifestVersion: 0,
+        apiKeys: [],
+        dependencies: options?.dependencies ?? [],
+        lifecycle: createActiveServiceLifecycle(),
+    };
+}
+/**
+ * Post a new Service instance row (L3 blueprint).
+ * Same `value` may exist on many rows; registry slot claim selects the live instance.
+ */
+async function postServiceInstance(options) {
+    const logger = options.logger ?? createLogger({ module: "service-bootstrap" });
+    const logTopic = options.logTopic ?? "bootstrap";
+    const result = await postService({
+        name: options.name,
+        value: options.value,
+        tagList: options.tagList ?? [],
+        details: defaultL3ServiceDetails({ dependencies: options.dependencies }),
+    });
+    if (!result.success || result.data == null) {
+        throw new Error(result.error?.message ?? "postService failed");
     }
+    logger.success("service instance created", {
+        topic: logTopic,
+        data: { value: options.value, serviceId: result.data.id },
+    });
+    return result.data;
 }
 
 const RETRYABLE_CAUSE_CODES = new Set([
@@ -1476,6 +2398,24 @@ async function fetchBinaryWithRetry(url, init, options) {
     return response.arrayBuffer();
 }
 
+/** Read a dotted path (e.g. `data.items`) from a parsed JSON value. */
+function getValueAtPath(value, path) {
+    if (path == null || path.trim() === "") {
+        return value;
+    }
+    let current = value;
+    for (const segment of path.split(".")) {
+        if (segment === "") {
+            continue;
+        }
+        if (current == null || typeof current !== "object") {
+            return undefined;
+        }
+        current = current[segment];
+    }
+    return current;
+}
+
 function fileBaseName(raw) {
     const normalized = raw.replace(/\\/g, "/");
     const parts = normalized.split("/");
@@ -1950,6 +2890,47 @@ const postTask = validateWithSchema(postTaskSchema, "postTaskSchema")(async ({ n
     return createTaskRow({ name, value, params, taskStatus, tagList, extra, traceParentId, taskTraceId }, logger);
 });
 
+const POST_TASK_DEFAULT_MAX_ATTEMPTS = 3;
+/**
+ * Retry wrapper for {@link postTask} — for schedule runners posting tasks over flaky network.
+ * Logs warn on intermediate failures and critical when all attempts fail.
+ */
+async function postTaskWithRetry(payload, options) {
+    const maxAttempts = options.maxAttempts ?? POST_TASK_DEFAULT_MAX_ATTEMPTS;
+    let lastError = "unknown error";
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+        const { data: task, error } = await postTask(payload);
+        if (error == null && task != null) {
+            return { ok: true, task };
+        }
+        lastError = error?.message ?? lastError;
+        if (attempt < maxAttempts) {
+            options.logger.warn("postTask failed, retrying", {
+                topic: options.topic,
+                data: {
+                    ...options.context,
+                    traceId: options.traceId,
+                    itemLabel: options.itemLabel,
+                    attempt,
+                    maxAttempts,
+                    error: lastError,
+                },
+            });
+        }
+    }
+    options.logger.critical("postTask failed after retries — skip item this cycle", {
+        topic: options.topic,
+        data: {
+            ...options.context,
+            traceId: options.traceId,
+            itemLabel: options.itemLabel,
+            maxAttempts,
+            error: lastError,
+        },
+    });
+    return { ok: false };
+}
+
 /** Count tasks of `taskType` grouped by each requested status. */
 function countTasksByType(tasks, taskType, statuses) {
     const filtered = tasks.filter((task) => task.value === taskType);
@@ -1969,5 +2950,5 @@ var CategoryWord;
     CategoryWord["WORD"] = "word";
 })(CategoryWord || (CategoryWord = {}));
 
-export { patchNodeHeartBeatSchema as $, ApiMethod as A, getParcelSchema as B, CategoryIdea as C, getScanRemoteRepoValues as D, getScanRemoteRepoValuesSchema as E, getService as F, getServiceSchema as G, installChunkFetchRegistry as H, isHttpUrl as I, isLocalFilesystemPath as J, isOpaqueChunkUrl as K, isRetryableHttpStatus as L, Market as M, NodeStatus as N, parcelDetailsSchema as O, ParcelManager as P, parseProviderPrefixedUrl as Q, ResultCode as R, ServiceLifecycleStatus as S, TASK_REPO_USAGE as T, patchChangeNodeStatus as U, patchChangeNodeStatusSchema as V, patchChangeTaskStatus as W, patchChangeTaskStatusSchema as X, patchClaimTask as Y, patchClaimTaskSchema as Z, patchNodeHeartBeat as _, CategoryLink as a, patchStopNode as a0, patchStopNodeSchema as a1, patchTaskProgress as a2, patchTaskProgressSchema as a3, postApi as a4, postApiSchema as a5, postLinkCreate as a6, postParcel as a7, postParcelSchema as a8, postRegisterNode as a9, postRegisterNodeSchema as aa, postService as ab, postServiceSchema as ac, postTask as ad, postTaskSchema as ae, publishParcel as af, registerProviderChunkResolver as ag, requestHasBody as ah, resolveFetchUrl as ai, restoreParcel as aj, restoreParcelById as ak, sanitizeFileName as al, sanitizeParcelFileName as am, schemaDefinitionSchema as an, serviceDetailsSchema as ao, serviceLifecycleSchema as ap, sha256Hex as aq, summarizeTaskQueue as ar, getErrorMessage as as, LOG_TOPIC_TASK as at, CRITICAL_UNKNOWN_TASK_TRACE_ID as au, toError as av, createTaskRow as aw, CategoryNode as b, CategoryParcel as c, CategoryRepo as d, CategoryService as e, CategoryTask as f, CategoryWord as g, PostLinkValidator as h, TaskStatus as i, TaskStatusAction as j, apiDetailsSchema as k, classifyNetworkError as l, countTasksByType as m, createStorageProviderRegistry as n, createUploadTracker as o, deleteParcel as p, deleteParcelSchema as q, discoverService as r, evaluateBusyNodeLiveness as s, fetchBinaryWithRetry as t, fetchWithRetry as u, fieldDefinitionSchema as v, formatNetworkError as w, getApi as x, getApiSchema as y, getParcel as z };
-//# sourceMappingURL=word.interface-DLgRobKV.js.map
+export { getConfigSchema as $, ApiMethod as A, createStorageProviderRegistry as B, CategoryConfig as C, DEFAULT_SYSTEM_REGISTRY_SEED_SLOTS as D, EMPTY_REGISTRY_SLOT_RUNTIME_STATE as E, createUploadTracker as F, decodeLogBatch as G, decodeLogBatchList as H, defaultL3ServiceDetails as I, deleteParcel as J, deleteParcelSchema as K, evaluateBusyNodeLiveness as L, Market as M, NodeStatus as N, fetchBinaryWithRetry as O, POST_TASK_DEFAULT_MAX_ATTEMPTS as P, fetchWithRetry as Q, ResultCode as R, ServiceLifecycleStatus as S, TARGET_SYSTEM_REGISTRY_KEY as T, fieldDefinitionSchema as U, flattenLogBatch as V, flattenLogBatches as W, formatNetworkError as X, getApi as Y, getApiSchema as Z, getConfig as _, CategoryExtraction as a, resolveFetchUrl as a$, getExtraction as a0, getExtractionSchema as a1, getParcel as a2, getParcelSchema as a3, getScanRemoteRepoValues as a4, getScanRemoteRepoValuesSchema as a5, getService as a6, getServiceSchema as a7, getTargetSystemRegistry as a8, getValueAtPath as a9, patchTaskProgressSchema as aA, postApi as aB, postApiSchema as aC, postExtraction as aD, postExtractionSchema as aE, postLinkCreate as aF, postParcel as aG, postParcelSchema as aH, postRegisterNode as aI, postRegisterNodeSchema as aJ, postService as aK, postServiceInstance as aL, postServiceSchema as aM, postSystemRegistryConfig as aN, postSystemRegistryConfigSchema as aO, postTask as aP, postTaskSchema as aQ, postTaskWithRetry as aR, publishParcel as aS, registerProviderChunkResolver as aT, registerService as aU, registerServiceAtStartup as aV, registrySlotRuntimePatchFromGuardResult as aW, requestHasBody as aX, resetSystemRegistryConfig as aY, resetSystemRegistryConfigSchema as aZ, resolveActiveRegistryServiceId as a_, installChunkFetchRegistry as aa, isHttpUrl as ab, isLocalFilesystemPath as ac, isLogBatchList as ad, isLogEntry as ae, isOpaqueChunkUrl as af, isRetryableHttpStatus as ag, parcelDetailsSchema as ah, parseLogBatchMeta as ai, parseProviderPrefixedUrl as aj, parseServiceSlot as ak, parseServiceSlots as al, patchChangeNodeStatus as am, patchChangeNodeStatusSchema as an, patchChangeTaskStatus as ao, patchChangeTaskStatusSchema as ap, patchClaimTask as aq, patchClaimTaskSchema as ar, patchExtractionObjects as as, patchExtractionObjectsSchema as at, patchNodeHeartBeat as au, patchNodeHeartBeatSchema as av, patchServiceRuntime as aw, patchStopNode as ax, patchStopNodeSchema as ay, patchTaskProgress as az, CategoryIdea as b, restoreParcel as b0, restoreParcelById as b1, runRegistrySlotGuardCheck as b2, sanitizeFileName as b3, sanitizeParcelFileName as b4, scanExtractionList as b5, scanExtractionListSchema as b6, schemaDefinitionSchema as b7, serviceDetailsSchema as b8, serviceLifecycleSchema as b9, serviceNodeSnapshotSchema as ba, serviceRuntimeSchema as bb, sha256Hex as bc, summarizeTaskQueue as bd, systemRegistrySeedSlotSchema as be, unregisterService as bf, unregisterServiceAtShutdown as bg, getErrorMessage as bh, LOG_TOPIC_TASK as bi, CRITICAL_UNKNOWN_TASK_TRACE_ID as bj, toError as bk, createTaskRow as bl, CategoryLink as c, CategoryNode as d, CategoryParcel as e, CategoryRepo as f, CategoryService as g, CategoryTask as h, CategoryWord as i, ParcelManager as j, PostLinkValidator as k, ServiceRegistryError as l, ServiceSlotStatus as m, TASK_REPO_USAGE as n, TaskStatus as o, TaskStatusAction as p, apiDetailsSchema as q, assertRegistrySlotAvailable as r, assertRegistrySlotOwner as s, buildEmptyServiceSlots as t, buildSystemRegistryConfigDetails as u, claimServiceRegistrySlot as v, classifyNetworkError as w, countTasksByType as x, createActiveServiceLifecycle as y, createClaimedRegistrySlotRuntimeState as z };
+//# sourceMappingURL=word.interface-B_fbVFOW.js.map