@noodleseed/one 0.161.1 → 0.162.0

package/node_modules/@noodle-borg/compiler/dist/managed-collections.js

@@ -0,0 +1,184 @@
+import { canonicalJson, sha256Canonical } from '@noodle-borg/app-package';
+import { z } from 'zod';
+export const MAX_MANAGED_COLLECTIONS = 16;
+export const MAX_MANAGED_COLLECTION_NAME_LENGTH = 64;
+export const MAX_MANAGED_COLLECTION_TITLE_LENGTH = 120;
+export const MAX_MANAGED_COLLECTION_DESCRIPTION_LENGTH = 1_000;
+export const MAX_MANAGED_COLLECTION_SCHEMA_VERSION = 2_147_483_647;
+export const MAX_MANAGED_COLLECTION_RECORD_SCHEMA_BYTES = 64 * 1024;
+export const MAX_MANAGED_COLLECTION_RECORD_SCHEMA_DEPTH = 12;
+export const MAX_MANAGED_COLLECTION_RECORD_FIELDS = 128;
+const collectionNameSchema = z
+    .string()
+    .min(1)
+    .max(MAX_MANAGED_COLLECTION_NAME_LENGTH)
+    .regex(/^[a-z][a-z0-9_]*$/, 'must start with a letter and use lowercase letters, numbers, and underscores');
+const jsonSchemaSchema = z.record(z.string(), z.unknown());
+export const managedCollectionManifestSchema = z
+    .object({
+    name: collectionNameSchema,
+    title: z.string().trim().min(1).max(MAX_MANAGED_COLLECTION_TITLE_LENGTH),
+    description: z.string().trim().min(1).max(MAX_MANAGED_COLLECTION_DESCRIPTION_LENGTH),
+    schemaVersion: z.number().int().positive().max(MAX_MANAGED_COLLECTION_SCHEMA_VERSION),
+    recordSchema: jsonSchemaSchema,
+})
+    .strict();
+const PROHIBITED_FIELD_NAME = /(?:card|cvv|cvc|password|passcode|token|secret|passport|governmentid|nationalid|socialsecurity|health|biometric)/i;
+const SUBSCHEMA_MAP_KEYS = [
+    'properties',
+    'patternProperties',
+    '$defs',
+    'dependentSchemas',
+];
+const SUBSCHEMA_KEYS = [
+    'items',
+    'additionalProperties',
+    'propertyNames',
+    'not',
+    'contains',
+    'if',
+    'then',
+    'else',
+];
+const SUBSCHEMA_LIST_KEYS = ['prefixItems', 'allOf', 'anyOf', 'oneOf'];
+/**
+ * Validate and lower reusable collection intent. Operator lifecycle, grants, residency, and
+ * retention deliberately do not enter this compiled definition.
+ */
+export function compileManagedCollections(collections, toolNames, errors) {
+    const compiled = [];
+    const seen = new Set();
+    collections.forEach((collection, index) => {
+        const path = `server.collections.${index}`;
+        if (seen.has(collection.name)) {
+            errors.push({
+                code: 'invalid_managed_collection',
+                path: `${path}.name`,
+                message: `duplicate managed collection name "${collection.name}"`,
+            });
+            return;
+        }
+        seen.add(collection.name);
+        const futureToolName = `submit_${collection.name}`;
+        const collision = toolNames.indexOf(futureToolName);
+        if (collision >= 0) {
+            errors.push({
+                code: 'reserved_name',
+                path: `tools.${collision}.name`,
+                message: `tool name "${futureToolName}" is reserved for managed collection "${collection.name}"`,
+            });
+        }
+        const schemaErrorsBefore = errors.length;
+        validateRecordSchema(collection.recordSchema, `${path}.recordSchema`, errors);
+        if (errors.length !== schemaErrorsBefore)
+            return;
+        compiled.push({
+            name: collection.name,
+            title: collection.title,
+            description: collection.description,
+            schemaVersion: collection.schemaVersion,
+            schemaDigest: sha256Canonical(collection.recordSchema),
+            recordSchema: collection.recordSchema,
+        });
+    });
+    return compiled;
+}
+function validateRecordSchema(schema, path, errors) {
+    const bytes = new TextEncoder().encode(canonicalJson(schema)).byteLength;
+    if (bytes > MAX_MANAGED_COLLECTION_RECORD_SCHEMA_BYTES) {
+        errors.push({
+            code: 'invalid_managed_collection',
+            path,
+            message: `record schema is ${bytes} UTF-8 bytes; the limit is ${MAX_MANAGED_COLLECTION_RECORD_SCHEMA_BYTES} bytes`,
+        });
+        return;
+    }
+    if (schema.type !== 'object' || schema.additionalProperties !== false) {
+        errors.push({
+            code: 'invalid_managed_collection',
+            path,
+            message: 'record schema must be a closed object with additionalProperties false',
+        });
+        return;
+    }
+    const state = { fields: 0, failure: undefined };
+    inspectSchema(schema, path, 1, state);
+    if (state.failure !== undefined)
+        errors.push(state.failure);
+}
+function inspectSchema(node, path, depth, state) {
+    if (state.failure !== undefined ||
+        node === null ||
+        typeof node !== 'object' ||
+        Array.isArray(node)) {
+        return;
+    }
+    if (depth > MAX_MANAGED_COLLECTION_RECORD_SCHEMA_DEPTH) {
+        state.failure = {
+            code: 'invalid_managed_collection',
+            path,
+            message: `record schema depth exceeds ${MAX_MANAGED_COLLECTION_RECORD_SCHEMA_DEPTH}`,
+        };
+        return;
+    }
+    const schema = node;
+    if (schema.type === 'object' && schema.additionalProperties !== false) {
+        state.failure = {
+            code: 'invalid_managed_collection',
+            path,
+            message: 'every record object must set additionalProperties to false',
+        };
+        return;
+    }
+    const properties = schema.properties;
+    if (isRecord(properties)) {
+        for (const [name, child] of Object.entries(properties)) {
+            state.fields += 1;
+            if (state.fields > MAX_MANAGED_COLLECTION_RECORD_FIELDS) {
+                state.failure = {
+                    code: 'invalid_managed_collection',
+                    path,
+                    message: `record schema declares more than ${MAX_MANAGED_COLLECTION_RECORD_FIELDS} fields`,
+                };
+                return;
+            }
+            if (PROHIBITED_FIELD_NAME.test(name.replace(/[^a-z0-9]/giu, ''))) {
+                state.failure = {
+                    code: 'invalid_managed_collection',
+                    path: `${path}.properties.${name}`,
+                    message: 'managed collection record schemas cannot declare prohibited sensitive fields',
+                };
+                return;
+            }
+            inspectSchema(child, `${path}.properties.${name}`, depth + 1, state);
+        }
+    }
+    for (const key of SUBSCHEMA_MAP_KEYS) {
+        if (key === 'properties')
+            continue;
+        const map = schema[key];
+        if (!isRecord(map))
+            continue;
+        for (const [name, child] of Object.entries(map)) {
+            inspectSchema(child, `${path}.${key}.${name}`, depth + 1, state);
+        }
+    }
+    for (const key of SUBSCHEMA_KEYS) {
+        const child = schema[key];
+        if (child !== undefined && typeof child !== 'boolean') {
+            inspectSchema(child, `${path}.${key}`, depth + 1, state);
+        }
+    }
+    for (const key of SUBSCHEMA_LIST_KEYS) {
+        const children = schema[key];
+        if (!Array.isArray(children))
+            continue;
+        children.forEach((child, index) => {
+            inspectSchema(child, `${path}.${key}.${index}`, depth + 1, state);
+        });
+    }
+}
+function isRecord(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+//# sourceMappingURL=managed-collections.js.map

package/node_modules/@noodle-borg/compiler/dist/manifest/schema.d.ts

@@ -1119,6 +1119,13 @@ export declare const manifestV2Schema: z.ZodObject<{
                 }, z.core.$strict>>;
             }, z.core.$strict>>;
         }, z.core.$strict>>>;
+        collections: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            title: z.ZodString;
+            description: z.ZodString;
+            schemaVersion: z.ZodNumber;
+            recordSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        }, z.core.$strict>>>;
     }, z.core.$strip>;
     tools: z.ZodArray<z.ZodObject<{
         name: z.ZodString;
@@ -2304,6 +2311,13 @@ export declare const manifestSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
                 }, z.core.$strict>>;
             }, z.core.$strict>>;
         }, z.core.$strict>>>;
+        collections: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            title: z.ZodString;
+            description: z.ZodString;
+            schemaVersion: z.ZodNumber;
+            recordSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        }, z.core.$strict>>>;
     }, z.core.$strip>;
     tools: z.ZodArray<z.ZodObject<{
         name: z.ZodString;

package/node_modules/@noodle-borg/compiler/dist/manifest/schema.js

@@ -1,5 +1,6 @@
 import { knowledgeComponentManifestSchema } from '@noodle-borg/knowledge/portable';
 import { z } from 'zod';
+import { MAX_MANAGED_COLLECTIONS, managedCollectionManifestSchema, } from '../managed-collections.js';
 import { MAX_COMPILED_WIDGET_HTML_BYTES, MAX_RAW_WIDGET_HTML_BYTES } from '../widget-limits.js';
 import { agentGuideSchema } from './agent-guide-schema.js';
 import { serverAuthSchema, serverAuthV2Schema } from './auth-schema.js';
@@ -420,6 +421,8 @@ const serverV2Schema = serverSchema.extend({
     agentGuide: agentGuideSchema.optional(),
     /** Customer-owned knowledge components (ADR 0202): Core v2 only. */
     knowledge: z.array(knowledgeComponentManifestSchema).optional(),
+    /** Managed business records: reusable schema intent only, never operator lifecycle state. */
+    collections: z.array(managedCollectionManifestSchema).max(MAX_MANAGED_COLLECTIONS).optional(),
 });
 const handoffSchema = z
     .object({

package/node_modules/@noodle-borg/service/dist/business-information/contracts.js

@@ -0,0 +1,5 @@
+export const MANAGED_RETENTION_DAYS = [7, 30, 90];
+export const BUSINESS_ROLES = ['administrator', 'manager', 'operator', 'viewer'];
+export const MANAGED_REQUEST_STATUSES = ['new', 'in_progress', 'resolved', 'closed'];
+export const BUILT_IN_PROFILE_KEYS = ['travel', 'b2b_saas', 'ecommerce', 'restaurant'];
+//# sourceMappingURL=contracts.js.map

package/node_modules/@noodle-borg/service/dist/business-information/in-memory-store.js

@@ -0,0 +1,402 @@
+import { randomUUID } from 'node:crypto';
+import { activityFromRecord, applyRequestOperation, cloneActivity, cloneGrant, cloneInstallation, cloneRecord, deletedRecord, idempotencyDigest, initialRecord, installationFingerprint, normalizeInstallationInput, permissionsForBusinessRole, requestFingerprint, validateCollectionEnabled, validateExpectedRevision, } from './model.js';
+import { afterCursor, compareRecords, decodeCursor, encodeCursor, recordKey, scopeKey, } from './pagination.js';
+import { boundedExportPageSize, boundedPageSize, validateEmail, validateScalar, validateScope, } from './validation.js';
+/** Process-local development/test adapter. Hosted services must use the PostgreSQL adapter. */
+export class InMemoryBusinessInformationStore {
+    #installations = new Map();
+    #installationIds = new Map();
+    #publicIds = new Map();
+    #installationFingerprints = new Map();
+    #grants = new Map();
+    #records = new Map();
+    #activities = new Map();
+    #idempotency = new Map();
+    #locks = new Map();
+    #now;
+    #id;
+    #publicId;
+    constructor(options = {}) {
+        this.#now = options.now ?? (() => new Date());
+        this.#id = options.id ?? randomUUID;
+        this.#publicId = options.publicId ?? (() => `sol_${randomUUID().replaceAll('-', '')}`);
+    }
+    async createInstallation(input) {
+        const normalized = normalizeInstallationInput(input);
+        const key = scopeKey(normalized.scope);
+        return this.#withLock(`installation:${normalized.scope.org}:${normalized.scope.installationId}`, async () => {
+            const existingKey = this.#installationIds.get(installationIdKey(normalized.scope.org, normalized.scope.installationId));
+            const existing = existingKey === undefined ? undefined : this.#installations.get(existingKey);
+            if (existing !== undefined) {
+                return {
+                    disposition: existingKey === key &&
+                        this.#installationFingerprints.get(key) === installationFingerprint(normalized)
+                        ? 'replayed'
+                        : 'conflict',
+                    installation: cloneInstallation(existing),
+                };
+            }
+            const now = this.#now().toISOString();
+            const installation = {
+                scope: { ...normalized.scope },
+                publicId: this.#uniquePublicId(),
+                profileKey: normalized.profileKey,
+                profileVersion: normalized.profileVersion,
+                managedCollections: [...normalized.managedCollections],
+                retentionDays: normalized.retentionDays,
+                revision: 1,
+                createdAt: now,
+                createdBySubject: normalized.actorSubject,
+                updatedAt: now,
+                updatedBySubject: normalized.actorSubject,
+            };
+            this.#installations.set(key, installation);
+            this.#installationIds.set(installationIdKey(normalized.scope.org, normalized.scope.installationId), key);
+            this.#publicIds.set(installation.publicId, key);
+            this.#installationFingerprints.set(key, installationFingerprint(normalized));
+            const administrator = {
+                scope: { ...normalized.scope },
+                subject: normalized.actorSubject,
+                ...(normalized.actorEmail === undefined ? {} : { email: normalized.actorEmail }),
+                role: 'administrator',
+                revision: 1,
+                createdAt: now,
+                createdBySubject: normalized.actorSubject,
+                updatedAt: now,
+                updatedBySubject: normalized.actorSubject,
+            };
+            this.#grants.set(grantKey(normalized.scope, normalized.actorSubject), administrator);
+            return { disposition: 'created', installation: cloneInstallation(installation) };
+        });
+    }
+    getInstallation(scope) {
+        const found = this.#installations.get(scopeKey(validateScope(scope)));
+        return Promise.resolve(found === undefined ? undefined : cloneInstallation(found));
+    }
+    getInstallationById(org, installationId) {
+        const key = this.#installationIds.get(installationIdKey(validateScalar('organization', org, 63), validateScalar('installation', installationId, 63)));
+        const found = key === undefined ? undefined : this.#installations.get(key);
+        return Promise.resolve(found === undefined ? undefined : cloneInstallation(found));
+    }
+    resolveInstallationByPublicId(publicId) {
+        const key = this.#publicIds.get(validateScalar('public installation id', publicId, 128));
+        const found = key === undefined ? undefined : this.#installations.get(key);
+        return Promise.resolve(found === undefined ? undefined : cloneInstallation(found));
+    }
+    listInstallations(org) {
+        const normalized = validateScalar('organization', org, 63);
+        return Promise.resolve([...this.#installations.values()]
+            .filter((installation) => installation.scope.org === normalized)
+            .sort((left, right) => left.createdAt.localeCompare(right.createdAt))
+            .map(cloneInstallation));
+    }
+    getGrant(scope, subject) {
+        const found = this.#grants.get(grantKey(validateScope(scope), subject));
+        return Promise.resolve(found === undefined ? undefined : cloneGrant(found));
+    }
+    listGrants(scope) {
+        const prefix = `${scopeKey(validateScope(scope))}\0`;
+        return Promise.resolve([...this.#grants.entries()]
+            .filter(([key]) => key.startsWith(prefix))
+            .map(([, grant]) => cloneGrant(grant))
+            .sort((left, right) => left.subject.localeCompare(right.subject)));
+    }
+    async setGrant(input) {
+        validateExpectedRevision(input.expectedRevision);
+        const subject = validateScalar('grant subject', input.subject, 256);
+        const actor = validateScalar('actor subject', input.actorSubject, 256);
+        permissionsForBusinessRole(input.role);
+        const scope = validateScope(input.scope);
+        const key = grantKey(scope, subject);
+        return this.#withLock(`grants:${scopeKey(scope)}`, async () => {
+            if (!(await this.getInstallation(input.scope)))
+                return { ok: false, reason: 'not_found', currentRevision: 0 };
+            const current = this.#grants.get(key);
+            const currentRevision = current?.revision ?? 0;
+            if (currentRevision !== input.expectedRevision) {
+                return { ok: false, reason: 'conflict', currentRevision };
+            }
+            if (current?.role === 'administrator' &&
+                current.revokedAt === undefined &&
+                input.role !== 'administrator' &&
+                this.#liveAdministratorCount(scope) === 1) {
+                return { ok: false, reason: 'last_administrator', currentRevision };
+            }
+            const now = this.#now().toISOString();
+            const grant = {
+                scope: { ...input.scope },
+                subject,
+                email: validateEmail(input.email),
+                role: input.role,
+                revision: currentRevision + 1,
+                createdAt: current?.createdAt ?? now,
+                createdBySubject: current?.createdBySubject ?? actor,
+                updatedAt: now,
+                updatedBySubject: actor,
+            };
+            this.#grants.set(key, grant);
+            return { ok: true, grant: cloneGrant(grant) };
+        });
+    }
+    async revokeGrant(input) {
+        validateExpectedRevision(input.expectedRevision);
+        const scope = validateScope(input.scope);
+        const key = grantKey(scope, input.subject);
+        return this.#withLock(`grants:${scopeKey(scope)}`, async () => {
+            const current = this.#grants.get(key);
+            if (current === undefined)
+                return { ok: false, reason: 'not_found', currentRevision: 0 };
+            if (current.revision !== input.expectedRevision) {
+                return { ok: false, reason: 'conflict', currentRevision: current.revision };
+            }
+            if (current.role === 'administrator' &&
+                current.revokedAt === undefined &&
+                this.#liveAdministratorCount(scope) === 1) {
+                return {
+                    ok: false,
+                    reason: 'last_administrator',
+                    currentRevision: current.revision,
+                };
+            }
+            const now = this.#now().toISOString();
+            const grant = {
+                ...current,
+                revision: current.revision + 1,
+                updatedAt: now,
+                updatedBySubject: validateScalar('actor subject', input.actorSubject, 256),
+                revokedAt: now,
+            };
+            this.#grants.set(key, grant);
+            return { ok: true, grant: cloneGrant(grant) };
+        });
+    }
+    async createRequest(input) {
+        const idempotencyKey = idempotencyDigest(input.idempotencyKey);
+        const installation = await this.#requiredInstallation(input.scope);
+        validateCollectionEnabled(installation, input.collectionKey);
+        const key = `${scopeKey(input.scope)}\0${input.collectionKey}\0${idempotencyKey}`;
+        return this.#withLock(`request-create:${key}`, async () => {
+            const candidate = initialRecord({
+                installation,
+                collectionKey: input.collectionKey,
+                id: this.#id(),
+                payload: input.payload,
+                origin: input.origin,
+                actorSubject: input.actorSubject,
+                now: this.#now(),
+            });
+            const fingerprint = requestFingerprint({
+                collectionKey: candidate.collectionKey,
+                payload: candidate.content?.payload,
+                origin: candidate.origin,
+                actorSubject: candidate.createdBySubject,
+            });
+            const replay = this.#idempotency.get(key);
+            if (replay !== undefined) {
+                const existing = this.#records.get(replay.recordKey);
+                if (existing === undefined)
+                    throw new Error('idempotency record points to a missing request');
+                return {
+                    disposition: replay.fingerprint === fingerprint ? 'replayed' : 'conflict',
+                    record: cloneRecord(existing),
+                };
+            }
+            const currentKey = recordKey(input.scope, candidate.collectionKey, candidate.id);
+            this.#records.set(currentKey, candidate);
+            this.#activities.set(currentKey, [activityFromRecord(candidate, 'created')]);
+            this.#idempotency.set(key, { fingerprint, recordKey: currentKey });
+            return { disposition: 'created', record: cloneRecord(candidate) };
+        });
+    }
+    #liveAdministratorCount(scope) {
+        const prefix = `${scopeKey(scope)}\0`;
+        return [...this.#grants.entries()].filter(([key, grant]) => key.startsWith(prefix) && grant.role === 'administrator' && grant.revokedAt === undefined).length;
+    }
+    async getRequest(scope, collectionKey, id, options = {}) {
+        const installation = await this.#requiredInstallation(scope);
+        const collection = validateCollectionEnabled(installation, collectionKey);
+        const record = this.#records.get(recordKey(scope, collection.key, validateScalar('record id', id, 128)));
+        if (record === undefined || (record.deletedAt !== undefined && options.includeDeleted !== true))
+            return undefined;
+        return cloneRecord(record);
+    }
+    async listRequests(input) {
+        const installation = await this.#requiredInstallation(input.scope);
+        const collection = validateCollectionEnabled(installation, input.collectionKey);
+        const limit = boundedPageSize(input.limit);
+        const cursor = input.cursor === undefined
+            ? undefined
+            : decodeCursor(input.cursor, {
+                kind: 'list',
+                scope: input.scope,
+                collectionKey: collection.key,
+            });
+        const records = this.#matchingRecords(input.scope, collection.key)
+            .filter((record) => input.includeDeleted === true || record.deletedAt === undefined)
+            .filter((record) => input.status === undefined || record.status === input.status)
+            .filter((record) => input.assigneeSubject === undefined || record.assigneeSubject === input.assigneeSubject)
+            .filter((record) => cursor === undefined || afterCursor(record, cursor));
+        return page(records, limit, 'list', input.scope, collection.key);
+    }
+    async mutateRequest(input) {
+        validateExpectedRevision(input.expectedRevision);
+        const installation = await this.#requiredInstallation(input.scope);
+        const collection = validateCollectionEnabled(installation, input.collectionKey);
+        const key = recordKey(input.scope, collection.key, validateScalar('record id', input.id, 128));
+        return this.#withLock(`request:${key}`, async () => {
+            const current = this.#records.get(key);
+            if (current === undefined || current.deletedAt !== undefined) {
+                return { ok: false, reason: 'not_found', currentRevision: 0 };
+            }
+            if (current.revision !== input.expectedRevision) {
+                return { ok: false, reason: 'conflict', currentRevision: current.revision };
+            }
+            const applied = applyRequestOperation(current, input.operation, input.actorSubject, this.#now(), this.#id);
+            if (applied === undefined) {
+                return { ok: false, reason: 'invalid_transition', currentRevision: current.revision };
+            }
+            this.#records.set(key, applied.record);
+            this.#activities.get(key)?.push(activityFromRecord(applied.record, applied.activityKind));
+            return { ok: true, record: cloneRecord(applied.record) };
+        });
+    }
+    async deleteRequest(input) {
+        validateExpectedRevision(input.expectedRevision);
+        const installation = await this.#requiredInstallation(input.scope);
+        const collection = validateCollectionEnabled(installation, input.collectionKey);
+        const key = recordKey(input.scope, collection.key, validateScalar('record id', input.id, 128));
+        return this.#withLock(`request:${key}`, () => Promise.resolve(this.#eraseRecord(key, input.expectedRevision, input.actorSubject, 'customer_request')));
+    }
+    listActivity(scope, collectionKey, id) {
+        const key = recordKey(validateScope(scope), collectionKey, validateScalar('record id', id, 128));
+        return Promise.resolve((this.#activities.get(key) ?? []).map(cloneActivity));
+    }
+    async exportRequests(input) {
+        const installation = await this.#requiredInstallation(input.scope);
+        const collection = validateCollectionEnabled(installation, input.collectionKey);
+        const limit = boundedExportPageSize(input.limit);
+        const cursor = input.cursor === undefined
+            ? undefined
+            : decodeCursor(input.cursor, {
+                kind: 'export',
+                scope: input.scope,
+                collectionKey: collection.key,
+            });
+        const snapshotAt = cursor?.snapshotAt ?? this.#now().toISOString();
+        if (snapshotAt === undefined)
+            throw new Error('export cursor is missing its snapshot');
+        const records = this.#matchingRecords(input.scope, collection.key)
+            .filter((record) => record.createdAt <= snapshotAt)
+            .filter((record) => input.includeDeleted === true || record.deletedAt === undefined)
+            .filter((record) => cursor === undefined || afterCursor(record, cursor));
+        return {
+            ...page(records, limit, 'export', input.scope, collection.key, snapshotAt),
+            snapshotAt,
+        };
+    }
+    async purgeExpired(input) {
+        const limit = boundedPageSize(input.limit);
+        const scope = input.scope === undefined ? undefined : scopeKey(validateScope(input.scope));
+        const now = this.#now();
+        const candidates = [...this.#records.entries()]
+            .filter(([key, record]) => (scope === undefined || key.startsWith(`${scope}\0`)) &&
+            record.deletedAt === undefined &&
+            record.retentionExpiresAt <= now.toISOString())
+            .slice(0, limit);
+        let purged = 0;
+        for (const [key, record] of candidates) {
+            const result = await this.#withLock(`request:${key}`, () => Promise.resolve(this.#eraseRecord(key, record.revision, 'system:retention', 'retention_expired')));
+            if (result.ok)
+                purged += 1;
+        }
+        return purged;
+    }
+    #matchingRecords(scope, collectionKey) {
+        const prefix = `${scopeKey(scope)}\0${collectionKey}\0`;
+        return [...this.#records.entries()]
+            .filter(([key]) => key.startsWith(prefix))
+            .map(([, record]) => record)
+            .sort(compareRecords);
+    }
+    #eraseRecord(key, expectedRevision, actorSubject, reason) {
+        const current = this.#records.get(key);
+        if (current === undefined || current.deletedAt !== undefined) {
+            return { ok: false, reason: 'not_found', currentRevision: current?.revision ?? 0 };
+        }
+        if (current.revision !== expectedRevision) {
+            return { ok: false, reason: 'conflict', currentRevision: current.revision };
+        }
+        const erased = deletedRecord(current, actorSubject, this.#now(), reason);
+        this.#records.set(key, erased);
+        const erasedHistory = (this.#activities.get(key) ?? []).map((activity) => {
+            const { content: ignored, ...metadata } = activity;
+            void ignored;
+            return metadata;
+        });
+        this.#activities.set(key, [
+            ...erasedHistory,
+            activityFromRecord(erased, reason === 'customer_request' ? 'deleted' : 'retention_expired'),
+        ]);
+        return { ok: true, record: cloneRecord(erased) };
+    }
+    async #requiredInstallation(scope) {
+        const installation = await this.getInstallation(scope);
+        if (installation === undefined)
+            throw new Error('solution installation was not found');
+        return installation;
+    }
+    #uniquePublicId() {
+        for (let attempt = 0; attempt < 8; attempt += 1) {
+            const candidate = validateScalar('public installation id', this.#publicId(), 128);
+            if (!this.#publicIds.has(candidate))
+                return candidate;
+        }
+        throw new Error('could not allocate a unique public installation id');
+    }
+    async #withLock(key, operation) {
+        const previous = this.#locks.get(key) ?? Promise.resolve();
+        let release = () => void 0;
+        const current = new Promise((resolve) => {
+            release = resolve;
+        });
+        const queued = previous.then(() => current);
+        this.#locks.set(key, queued);
+        await previous;
+        try {
+            return await operation();
+        }
+        finally {
+            release(undefined);
+            if (this.#locks.get(key) === queued)
+                this.#locks.delete(key);
+        }
+    }
+}
+function installationIdKey(org, installationId) {
+    return `${org}\0${installationId}`;
+}
+function grantKey(scope, subject) {
+    return `${scopeKey(scope)}\0${validateScalar('grant subject', subject, 256)}`;
+}
+function page(records, limit, kind, scope, collectionKey, snapshotAt) {
+    const selected = records.slice(0, limit).map(cloneRecord);
+    const last = selected.at(-1);
+    const hasMore = records.length > limit;
+    return {
+        records: selected,
+        ...(hasMore && last !== undefined
+            ? {
+                nextCursor: encodeCursor({
+                    version: 1,
+                    kind,
+                    scope: scopeKey(scope),
+                    collectionKey,
+                    lastCreatedAt: last.createdAt,
+                    lastId: last.id,
+                    ...(snapshotAt === undefined ? {} : { snapshotAt }),
+                }),
+            }
+            : {}),
+    };
+}
+//# sourceMappingURL=in-memory-store.js.map