@x12i/static-memorix 2.0.0

package/dist/engine/query.js

@@ -0,0 +1,191 @@
+import mingo from "mingo";
+export function parseFilterToken(token) {
+    const idx1 = token.indexOf(":");
+    if (idx1 === -1)
+        return null;
+    const field = token.slice(0, idx1);
+    const rest = token.slice(idx1 + 1);
+    const idx2 = rest.indexOf(":");
+    if (idx2 === -1) {
+        // treat as eq
+        return { field, op: "eq", value: coerce(rest), raw: token };
+    }
+    const op = rest.slice(0, idx2);
+    const value = rest.slice(idx2 + 1);
+    // Narrative virtual filter interception: narrativeId:eq:has-vulns /
+    // narrativeKey:eq:has-vulns  ->  evaluate doc.narratives['has-vulns'].
+    if (field === "narrativeId" || field === "narrativeKey") {
+        return {
+            field,
+            op: op || "eq",
+            value: coerceForOp(op || "eq", value),
+            raw: token,
+            isVirtual: true,
+        };
+    }
+    if (!["eq", "ne", "gt", "gte", "lt", "lte", "in", "nin", "exists", "regex"].includes(op)) {
+        return { field, op: "eq", value: coerce(rest), raw: token };
+    }
+    return { field, op, value: coerceForOp(op, value), raw: token };
+}
+export function coerce(value) {
+    if (value === "true")
+        return true;
+    if (value === "false")
+        return false;
+    if (value === "null")
+        return null;
+    if (value !== "" && !isNaN(Number(value)))
+        return Number(value);
+    return value;
+}
+function coerceForOp(op, value) {
+    if (op === "in" || op === "nin") {
+        return value
+            .split("|")
+            .map((v) => coerce(v.trim()))
+            .filter((v) => v !== "");
+    }
+    if (op === "exists") {
+        return !(value === "false" || value === "0");
+    }
+    if (op === "regex") {
+        return value;
+    }
+    return coerce(value);
+}
+/**
+ * Parse the filter param. Supports repeated values (array) and `;` separators.
+ * Returns virtual narrative filters separately so the caller can rewrite them.
+ */
+export function parseExplorerFilters(filter) {
+    const tokens = toArray(filter)
+        .flatMap((f) => f.split(";"))
+        .map((f) => f.trim())
+        .filter(Boolean);
+    const criteria = {};
+    const virtual = [];
+    for (const token of tokens) {
+        const parsed = parseFilterToken(token);
+        if (!parsed)
+            continue;
+        if (parsed.isVirtual) {
+            virtual.push(parsed);
+            continue;
+        }
+        applyFilterToCriteria(criteria, parsed);
+    }
+    return { criteria, virtual };
+}
+function applyFilterToCriteria(criteria, parsed) {
+    const { field, op, value } = parsed;
+    switch (op) {
+        case "eq":
+            criteria[field] = value;
+            break;
+        case "ne":
+            criteria[field] = { $ne: value };
+            break;
+        case "gt":
+            criteria[field] = { $gt: value };
+            break;
+        case "gte":
+            criteria[field] = { $gte: value };
+            break;
+        case "lt":
+            criteria[field] = { $lt: value };
+            break;
+        case "lte":
+            criteria[field] = { $lte: value };
+            break;
+        case "in":
+            criteria[field] = { $in: value };
+            break;
+        case "nin":
+            criteria[field] = { $nin: value };
+            break;
+        case "exists":
+            criteria[field] = { $exists: value };
+            break;
+        case "regex":
+            criteria[field] = { $regex: value, $options: "i" };
+            break;
+    }
+}
+export function parseSortParams(sort) {
+    const tokens = toArray(sort)
+        .flatMap((s) => s.split(";"))
+        .map((s) => s.trim())
+        .filter(Boolean);
+    const sortSpec = {};
+    for (const token of tokens) {
+        const [field, dirRaw] = token.split(":");
+        const dir = (dirRaw || "asc").toLowerCase();
+        sortSpec[field] = dir === "desc" ? -1 : 1;
+    }
+    return sortSpec;
+}
+function toArray(v) {
+    if (v === undefined || v === null)
+        return [];
+    return Array.isArray(v) ? v : [v];
+}
+/**
+ * Resolve virtual narrative filters into a predicate that checks
+ * doc.narratives[key] presence / truthiness.
+ */
+export function applyVirtualNarrativeFilters(records, virtual) {
+    if (virtual.length === 0)
+        return records;
+    return records.filter((doc) => {
+        const narratives = doc.narratives || {};
+        return virtual.every((vf) => {
+            const key = String(vf.value);
+            const actual = narratives[key];
+            if (vf.op === "exists")
+                return vf.value ? actual !== undefined : actual === undefined;
+            if (vf.op === "eq")
+                return actual === true || actual === vf.value;
+            return true;
+        });
+    });
+}
+/**
+ * Execute a query against an in-memory record array using mingo, with
+ * full-text search, virtual narrative filters, sorting, and pagination.
+ */
+export function queryMockCollection(records, queryParams) {
+    let pipeline = [...records];
+    // 1. Intercept narrative virtual filters
+    const { criteria, virtual } = parseExplorerFilters(queryParams.filter);
+    pipeline = applyVirtualNarrativeFilters(pipeline, virtual);
+    // 2. Full-Text Search
+    const term = (queryParams.searchText || queryParams.q || "").toLowerCase();
+    if (term) {
+        pipeline = pipeline.filter((doc) => JSON.stringify(doc).toLowerCase().includes(term));
+    }
+    // 3. Mingo Mongo Query Execution
+    const query = new mingo.Query(criteria);
+    let cursor = query.find(pipeline);
+    // 4. Sorting
+    const sortSpec = parseSortParams(queryParams.sort);
+    if (Object.keys(sortSpec).length > 0) {
+        cursor = cursor.sort(sortSpec);
+    }
+    // Materialize all matched docs (mingo cursors are single-use, so we cannot
+    // call .count() and then .all() on the same cursor).
+    const matched = cursor.all();
+    const total = matched.length;
+    // 5. Pagination
+    const limit = Math.min(Number(queryParams.limit) || 50, 500);
+    const offset = Number(queryParams.offset) || Number(queryParams.skip) || 0;
+    const rows = matched.slice(offset, offset + limit);
+    return {
+        rows,
+        page: {
+            offset,
+            limit,
+            total: queryParams.includeTotal ? total : undefined,
+        },
+    };
+}

package/dist/engine/records.d.ts

@@ -0,0 +1,23 @@
+import { type ContentType, type ExplorerQueryParams, type IdentityKey } from "../types.js";
+export declare function inferIdField(entityName: string, ct: ContentType): string;
+/**
+ * Find a record within a collection using an identity map (recordId, entityId,
+ * eventId, knowledgeId, or memoryId). At least one identity key is required.
+ */
+export declare function findRecordByIdentity(entityName: string, ct: ContentType, identity: Partial<Record<IdentityKey, string>>): any | undefined;
+export declare function findRecord(entityName: string, ct: ContentType, recordId: string): any | undefined;
+export declare function getRecordsCollection(params: ExplorerQueryParams): Promise<{
+    rows: any[];
+    page: any;
+}>;
+export declare function getRecordsFull(entityName: string, recordId: string): any;
+export declare function getRecordsItem(entityName: string, recordId: string, itemDescriptor?: any): any;
+/**
+ * Fetch a single content record by id. Supports the memory tier via memoryId.
+ * If entityName is empty and contentType is "memory", defaults to "memory".
+ * Otherwise, searches across all object types in the store.
+ */
+export declare function getRecordContent(entityName: string, contentType: ContentType, identity: Partial<Record<IdentityKey, string>>): any | undefined;
+export declare function getRawCollection(entityName: string, collectionName: string): any[];
+export declare function getRawItem(collectionName: string, recordId: string): any | undefined;
+export declare function getWorkspaceRecords(params: ExplorerQueryParams): Promise<any>;

package/dist/engine/records.js

@@ -0,0 +1,152 @@
+import { store } from "../storage/InMemoryStore.js";
+import { CONTENT_TYPES, } from "../types.js";
+import { queryMockCollection } from "../engine/query.js";
+import { executeListDescriptor, getListDescriptor } from "../engine/lists.js";
+import { findByIdentity } from "../engine/identity.js";
+export function inferIdField(entityName, ct) {
+    if (ct === "memory")
+        return "memoryId";
+    const sample = store.getCollection(entityName, ct)[0];
+    if (sample) {
+        if ("recordId" in sample)
+            return "recordId";
+        if ("entityId" in sample)
+            return "entityId";
+        if ("id" in sample)
+            return "id";
+    }
+    return "recordId";
+}
+/**
+ * Find a record within a collection using an identity map (recordId, entityId,
+ * eventId, knowledgeId, or memoryId). At least one identity key is required.
+ */
+export function findRecordByIdentity(entityName, ct, identity) {
+    const records = store.getCollection(entityName, ct);
+    return findByIdentity(records, identity);
+}
+export function findRecord(entityName, ct, recordId) {
+    const idField = inferIdField(entityName, ct);
+    return store
+        .getCollection(entityName, ct)
+        .find((d) => String(d[idField]) === String(recordId));
+}
+export async function getRecordsCollection(params) {
+    const target = params.target;
+    // The `memory` target routes to the memory tier regardless of entityName.
+    if (target === "memory") {
+        const ct = "memory";
+        const records = store.getCollection("memory", ct);
+        return queryMockCollection(records, params);
+    }
+    const entityName = params.entityName;
+    const mode = params.mode || "auto";
+    const listId = params.listId;
+    if (mode === "descriptor" || (mode === "auto" && listId)) {
+        const resolvedListId = listId || `${entityName}-default`;
+        const listSpec = getListDescriptor(resolvedListId);
+        if (listSpec) {
+            return executeListDescriptor(listSpec, params);
+        }
+        // fall through to raw if descriptor missing
+    }
+    const ct = params.contentType || "snapshots";
+    const records = store.getCollection(entityName, ct);
+    return queryMockCollection(records, params);
+}
+export function getRecordsFull(entityName, recordId) {
+    const identity = { recordId };
+    const snapshot = findRecordByIdentity(entityName, "snapshots", identity);
+    const analysis = findRecordByIdentity(entityName, "analysis", identity);
+    const decisions = findRecordByIdentity(entityName, "decisions", identity);
+    const memory = findRecordByIdentity(entityName, "memory", identity);
+    return {
+        recordId,
+        entityName,
+        contentTypes: { snapshot, analysis, decisions, memory },
+    };
+}
+export function getRecordsItem(entityName, recordId, itemDescriptor) {
+    const record = findRecordByIdentity(entityName, "snapshots", { recordId });
+    if (!record)
+        return undefined;
+    if (!itemDescriptor)
+        return record;
+    // Hydrate sections/fields from metadata/items
+    const sections = itemDescriptor.sections || [];
+    const out = { recordId, entityName };
+    for (const section of sections) {
+        const fields = section.fields || [];
+        out[section.key || section.id] = fields.map((f) => ({
+            field: f.field || f.key,
+            value: getPath(record, f.field || f.key),
+            label: f.label,
+        }));
+    }
+    return out;
+}
+/**
+ * Fetch a single content record by id. Supports the memory tier via memoryId.
+ * If entityName is empty and contentType is "memory", defaults to "memory".
+ * Otherwise, searches across all object types in the store.
+ */
+export function getRecordContent(entityName, contentType, identity) {
+    if (contentType === "memory") {
+        entityName = entityName || "memory";
+        return findRecordByIdentity(entityName, contentType, identity);
+    }
+    if (!entityName) {
+        // Search across all collections for the identity key
+        const keys = store.getCollectionKeys();
+        for (const key of keys) {
+            const [ot, ct] = key.split("/");
+            if (ct !== contentType)
+                continue;
+            const found = findRecordByIdentity(ot, contentType, identity);
+            if (found)
+                return found;
+        }
+        return undefined;
+    }
+    return findRecordByIdentity(entityName, contentType, identity);
+}
+export function getRawCollection(entityName, collectionName) {
+    // memory tier is keyed by a standalone `memory` object type
+    if (collectionName === "memory" || entityName === "memory") {
+        return store.getCollection("memory", "memory");
+    }
+    const ct = collectionName;
+    if (CONTENT_TYPES.includes(ct)) {
+        return store.getCollection(entityName, ct);
+    }
+    // allow objectType/contentType form
+    const [ot, c] = collectionName.split("/");
+    if (CONTENT_TYPES.includes(c)) {
+        return store.getCollection(ot, c);
+    }
+    return [];
+}
+export function getRawItem(collectionName, recordId) {
+    if (collectionName === "memory") {
+        return findRecordByIdentity("memory", "memory", { memoryId: recordId });
+    }
+    const ct = collectionName;
+    if (CONTENT_TYPES.includes(ct)) {
+        return findRecordByIdentity("memory", ct, { recordId }) ??
+            findRecord("__any__", ct, recordId);
+    }
+    const [entityName, c] = collectionName.split("/");
+    return findRecord(entityName, c, recordId);
+}
+export async function getWorkspaceRecords(params) {
+    // cross-entity query using a workspace list descriptor
+    const listId = params.listId || "workspace-default";
+    const listSpec = getListDescriptor(listId);
+    if (!listSpec) {
+        return { rows: [], page: { offset: 0, limit: 50 } };
+    }
+    return executeListDescriptor(listSpec, params);
+}
+function getPath(obj, path) {
+    return path.split(".").reduce((acc, k) => (acc == null ? undefined : acc[k]), obj);
+}

package/dist/engine/snapshots.d.ts

@@ -0,0 +1,17 @@
+export declare function getSnapshotRaw(objectType: string, recordId: string): {
+    rawDoc: any;
+    idField: string;
+} | undefined;
+export declare function getSnapshotNormalized(objectType: string, recordId: string, include?: string | string[]): any | undefined;
+export declare function getSnapshotAssociated(objectType: string, recordId: string): any | undefined;
+export declare function getSnapshotAssociatedProperty(objectType: string, recordId: string, propertyName: string): any | undefined;
+export declare function getAssociatedProperties(objectType: string): Array<{
+    propertyName: string;
+    source: string;
+    count: number;
+}>;
+/**
+ * Deterministic fingerprint for association plan/apply/verify.
+ */
+export declare function computeAssociationFingerprint(objectType: string): string;
+export declare function hashString(s: string): string;

package/dist/engine/snapshots.js

@@ -0,0 +1,110 @@
+import { store } from "../storage/InMemoryStore.js";
+import { buildAssociatedBucket, aliasClientToStorage, resolveInclude, } from "../engine/aliases.js";
+import { inferIdField } from "../engine/records.js";
+export function getSnapshotRaw(objectType, recordId) {
+    const idField = inferIdField(objectType, "snapshots");
+    const rawDoc = store
+        .getCollection(objectType, "snapshots")
+        .find((d) => String(d[idField]) === String(recordId));
+    if (!rawDoc)
+        return undefined;
+    return { rawDoc, idField };
+}
+export function getSnapshotNormalized(objectType, recordId, include) {
+    const found = getSnapshotRaw(objectType, recordId);
+    if (!found)
+        return undefined;
+    const { rawDoc } = found;
+    const { associated, strippedDoc } = buildAssociatedBucket(rawDoc);
+    const flags = resolveInclude(include);
+    const out = { ...strippedDoc, associated };
+    if (flags) {
+        for (const flag of flags) {
+            applyIncludeFlag(out, rawDoc, associated, flag);
+        }
+    }
+    return out;
+}
+function applyIncludeFlag(out, rawDoc, associated, flag) {
+    switch (flag) {
+        case "data":
+            out.data = associated.data ?? rawDoc.associatedData ?? [];
+            break;
+        case "discovery":
+            out.discovery =
+                associated.discovery ?? rawDoc.associatedInferred ?? rawDoc.associatedDiscovery ?? [];
+            break;
+        case "analysis":
+            out.analysis = associated.analysis ?? rawDoc.associatedAnalysis ?? [];
+            break;
+        case "enrichment":
+            out.enrichment = rawDoc.enrichment ?? [];
+            break;
+        case "insights":
+            out.insights = rawDoc.insights ?? [];
+            break;
+        case "system":
+            out.system = rawDoc.system ?? {};
+            break;
+        case "associated":
+            out.associated = associated;
+            break;
+    }
+}
+export function getSnapshotAssociated(objectType, recordId) {
+    const found = getSnapshotRaw(objectType, recordId);
+    if (!found)
+        return undefined;
+    const { associated, properties } = buildAssociatedBucket(found.rawDoc);
+    return { associated, properties };
+}
+export function getSnapshotAssociatedProperty(objectType, recordId, propertyName) {
+    const found = getSnapshotRaw(objectType, recordId);
+    if (!found)
+        return undefined;
+    const { associated } = buildAssociatedBucket(found.rawDoc);
+    if (propertyName in associated) {
+        return associated[propertyName];
+    }
+    // try alias resolution
+    const { fallbacks } = aliasClientToStorage(propertyName);
+    for (const fb of fallbacks) {
+        if (fb in found.rawDoc)
+            return found.rawDoc[fb];
+    }
+    return undefined;
+}
+export function getAssociatedProperties(objectType) {
+    const records = store.getCollection(objectType, "snapshots");
+    const agg = new Map();
+    for (const doc of records) {
+        for (const k of Object.keys(doc)) {
+            if (k.startsWith("associated")) {
+                const existing = agg.get(k) || { source: k, count: 0 };
+                const v = doc[k];
+                existing.count += Array.isArray(v) ? v.length : v != null ? 1 : 0;
+                agg.set(k, existing);
+            }
+        }
+    }
+    return [...agg.entries()].map(([source, v]) => ({
+        propertyName: source,
+        source,
+        count: v.count,
+    }));
+}
+/**
+ * Deterministic fingerprint for association plan/apply/verify.
+ */
+export function computeAssociationFingerprint(objectType) {
+    const records = store.getCollection(objectType, "snapshots");
+    const serialized = JSON.stringify(records.map((r) => ({ id: r.id ?? r.recordId, keys: Object.keys(r) })));
+    return `fp:${objectType}:${hashString(serialized)}`;
+}
+export function hashString(s) {
+    let h = 5381;
+    for (let i = 0; i < s.length; i++) {
+        h = (h * 33) ^ s.charCodeAt(i);
+    }
+    return (h >>> 0).toString(16);
+}

package/dist/engine/write.d.ts

@@ -0,0 +1,30 @@
+import type { ContentType, WriteDescriptor } from "../types.js";
+export type WriteOperation = "add" | "upsert" | "patch" | "replace" | "delete";
+export declare function loadWriteDescriptor(writeDescriptorId: string): WriteDescriptor;
+export interface ValidationResult {
+    ok: boolean;
+    errors: string[];
+}
+/**
+ * Validate input against the write descriptor schema (lightweight AJV-free check).
+ *
+ * `operation` controls how `required` is enforced:
+ *   - `add` / `replace`: every field in `schema.required` must be present.
+ *   - `upsert` / `patch` / `delete`: only the collection's identity field
+ *     (e.g. `recordId`, `memoryId`) is required; other `required` entries are
+ *     ignored because partial updates are allowed.
+ *
+ * Type checks on whatever fields ARE present always run.
+ */
+export declare function validateInputSchema(writeSpec: WriteDescriptor, input: any, operation?: WriteOperation): ValidationResult;
+export declare function parseTargetCollection(target: string): {
+    objectType: string;
+    ct: ContentType;
+};
+export declare function executeOperation(params: {
+    target: string;
+    op: WriteOperation;
+    data: any;
+    persist?: boolean;
+}): any[];
+export declare function listWriteDescriptors(): WriteDescriptor[];

package/dist/engine/write.js

@@ -0,0 +1,163 @@
+import { store } from "../storage/InMemoryStore.js";
+export function loadWriteDescriptor(writeDescriptorId) {
+    const desc = store.getMeta(`write-descriptors/${writeDescriptorId}`);
+    if (!desc) {
+        throw Object.assign(new Error(`Write descriptor not found: ${writeDescriptorId}`), {
+            statusCode: 404,
+        });
+    }
+    return desc;
+}
+/**
+ * Validate input against the write descriptor schema (lightweight AJV-free check).
+ *
+ * `operation` controls how `required` is enforced:
+ *   - `add` / `replace`: every field in `schema.required` must be present.
+ *   - `upsert` / `patch` / `delete`: only the collection's identity field
+ *     (e.g. `recordId`, `memoryId`) is required; other `required` entries are
+ *     ignored because partial updates are allowed.
+ *
+ * Type checks on whatever fields ARE present always run.
+ */
+export function validateInputSchema(writeSpec, input, operation = "add") {
+    const errors = [];
+    const schema = (writeSpec.schema || {});
+    const payload = Array.isArray(input) ? input : input ? [input] : [];
+    const partial = operation === "upsert" || operation === "patch" || operation === "delete";
+    if (schema.required && Array.isArray(schema.required)) {
+        // Determine the identity field for this descriptor based on targetCollection.
+        const targetCollection = writeSpec.targetCollection || "";
+        const [, ctRaw] = targetCollection.split("/");
+        const idField = ctRaw === "memory" ? "memoryId" : "recordId";
+        for (const req of schema.required) {
+            for (const item of payload) {
+                if (item?.[req] === undefined) {
+                    // In partial modes, only the identity field is mandatory.
+                    if (partial && req !== idField)
+                        continue;
+                    errors.push(`Missing required field: ${req}`);
+                }
+            }
+        }
+    }
+    if (schema.properties) {
+        for (const item of payload) {
+            for (const [field, def] of Object.entries(schema.properties)) {
+                if (item[field] === undefined || item[field] === null)
+                    continue;
+                if (def.type) {
+                    const actualType = Array.isArray(item[field]) ? "array" : typeof item[field];
+                    const expected = def.type;
+                    if (expected === "array" && !Array.isArray(item[field])) {
+                        errors.push(`Field ${field} must be array`);
+                    }
+                    else if (expected !== "array" && expected !== actualType) {
+                        errors.push(`Field ${field} must be ${expected}, got ${actualType}`);
+                    }
+                }
+            }
+        }
+    }
+    return { ok: errors.length === 0, errors };
+}
+export function parseTargetCollection(target) {
+    const [objectType, ctRaw] = target.split("/");
+    // The `memory` target routes to the standalone memory tier.
+    if (objectType === "memory" || ctRaw === "memory") {
+        return { objectType: "memory", ct: "memory" };
+    }
+    const ct = (ctRaw || "snapshots");
+    return { objectType, ct };
+}
+export function executeOperation(params) {
+    const { objectType, ct } = parseTargetCollection(params.target);
+    // Work on a copy so dry runs cannot leak into the live in-memory store and
+    // later get persisted by an unrelated write.
+    const collection = [...store.getCollection(objectType, ct)];
+    const payload = Array.isArray(params.data) ? params.data : [params.data];
+    const persist = params.persist !== false;
+    // Resolve the identity field for this collection tier.
+    // Memory tier uses memoryId; everything else defaults to recordId.
+    const idField = ct === "memory" ? "memoryId" : "recordId";
+    switch (params.op) {
+        case "add": {
+            const nextId = getNextId(collection, idField);
+            for (const item of payload) {
+                collection.push({ ...item, [idField]: item[idField] ?? nextId() });
+            }
+            break;
+        }
+        case "upsert": {
+            for (const item of payload) {
+                const id = item[idField] ?? item.recordId ?? item.id;
+                const idx = collection.findIndex((d) => (d[idField] ?? d.recordId ?? d.id) === id);
+                if (idx >= 0) {
+                    collection[idx] = { ...collection[idx], ...item };
+                }
+                else {
+                    collection.push(item);
+                }
+            }
+            break;
+        }
+        case "patch": {
+            for (const item of payload) {
+                const id = item[idField] ?? item.recordId ?? item.id;
+                const idx = collection.findIndex((d) => (d[idField] ?? d.recordId ?? d.id) === id);
+                if (idx >= 0) {
+                    collection[idx] = { ...collection[idx], ...item };
+                }
+            }
+            break;
+        }
+        case "replace": {
+            if (persist)
+                store.setCollection(objectType, ct, payload);
+            return payload;
+        }
+        case "delete": {
+            const removed = [];
+            for (const item of payload) {
+                const id = item[idField] ?? item.recordId ?? item.id;
+                if (id === undefined)
+                    continue;
+                let i = collection.length;
+                while (i--) {
+                    const candidate = collection[i];
+                    if ((candidate[idField] ?? candidate.recordId ?? candidate.id) === id) {
+                        removed.push(collection.splice(i, 1)[0]);
+                    }
+                }
+            }
+            if (persist)
+                store.setCollection(objectType, ct, collection);
+            return removed;
+        }
+        default:
+            throw Object.assign(new Error(`Unsupported write operation: ${params.op}`), {
+                statusCode: 400,
+            });
+    }
+    if (persist)
+        store.setCollection(objectType, ct, collection);
+    return payload;
+}
+function getNextId(collection, idField = "recordId") {
+    let max = 0;
+    for (const d of collection) {
+        const id = Number(d[idField] ?? d.recordId ?? d.id);
+        if (!isNaN(id) && id > max)
+            max = id;
+    }
+    let counter = max + 1;
+    return () => String(counter++);
+}
+export function listWriteDescriptors() {
+    const out = [];
+    for (const key of store.getMetaKeys().filter((item) => item.startsWith("write-descriptors/"))) {
+        const desc = store.getMeta(key);
+        if (desc)
+            out.push(desc);
+    }
+    return out;
+}