@noodleseed/one 0.161.2 → 0.163.0

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

@@ -0,0 +1,557 @@
+import { randomUUID } from 'node:crypto';
+import { memoryActivityPage } from './activity-pagination.js';
+import { collectionControlEnabled } from './collection-controls.js';
+import { InMemoryInstallationLifecycle, } from './in-memory-installation-lifecycle.js';
+import { InMemoryBusinessInvitations } from './in-memory-invitations.js';
+import { BusinessMemoryLocks } from './in-memory-locks.js';
+import { InstallationCapacityError, MAX_RETAINED_INSTALLATIONS_PER_ORG, } from './installation-capacity.js';
+import { migrateLegacyRequestRecord } from './legacy-request-migration.js';
+import { activityFromRecord, applyRequestOperation, cloneGrant, cloneRecord, deletedRecord, effectiveInstallation, idempotencyDigest, initialRecord, installationFingerprint, managedInstallationIntentMatches, normalizeInstallationInput, permissionsForBusinessRole, requestFingerprint, validateCollectionEnabled, validateExpectedRevision, validateStoredRecord, } from './model.js';
+import { matchesNativeQueryMetadata, planNativeQuery, runNativeQuery } from './native-query.js';
+import { commitNativeMemoryRecord, NativeStorageBudget } from './native-storage-budget.js';
+import { afterCursor, compareRecords, decodeCursor, grantKey, installationIdKey, page, recordKey, scopeKey, } from './pagination.js';
+import { BusinessPrincipalAuthority, } from './principal-authority.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();
+    #invitations;
+    #lifecycle;
+    #principals = new BusinessPrincipalAuthority();
+    #custody = new NativeStorageBudget();
+    #records = new Map();
+    #activities = new Map();
+    #idempotency = new Map();
+    #locks = new BusinessMemoryLocks();
+    #now;
+    #id;
+    #publicId;
+    #managedDefinition;
+    constructor(options = {}) {
+        this.#now = options.now ?? (() => new Date());
+        this.#id = options.id ?? randomUUID;
+        this.#publicId = options.publicId ?? (() => `sol_${randomUUID().replaceAll('-', '')}`);
+        this.#managedDefinition = options.managedDefinition;
+        this.#lifecycle = new InMemoryInstallationLifecycle({
+            installations: this.#installations,
+            getGrant: (scope, subject) => this.#grants.get(grantKey(scope, subject)),
+            withLock: (key, operation) => this.#locks.run(key, operation),
+            now: this.#now,
+            managedDefinition: this.#managedDefinition,
+        });
+        this.#invitations = new InMemoryBusinessInvitations({
+            now: this.#now,
+            getInstallation: (scope) => this.getInstallation(scope),
+            getGrant: (scope, subject) => this.getGrant(scope, subject),
+            putGrant: (grant) => this.#grants.set(grantKey(grant.scope, grant.subject), grant),
+            withGrantLock: (scope, operation) => this.#locks.run(`grants:${scopeKey(scope)}`, operation),
+            liveAdministratorCount: (scope) => this.#liveAdministratorCount(scope),
+        });
+    }
+    configurePrincipalAuthority(provider) {
+        this.#principals.configure(provider);
+    }
+    async listEligibleAssignees(scope) {
+        return this.#principals.eligible(await this.listGrants(scope));
+    }
+    getBusinessNotice(scope) {
+        return this.#lifecycle.getBusinessNotice(scope);
+    }
+    setBusinessNotice(input) {
+        return this.#lifecycle.setBusinessNotice(input);
+    }
+    async createInstallation(input) {
+        const normalized = normalizeInstallationInput(input);
+        const key = scopeKey(normalized.scope);
+        return this.#locks.run(`installations:${normalized.scope.org}`, 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) ||
+                            managedInstallationIntentMatches(existing, normalized))
+                        ? 'replayed'
+                        : 'conflict',
+                    installation: effectiveInstallation(existing, this.#managedDefinition),
+                };
+            }
+            if ([...this.#installations.values()].filter((entry) => entry.scope.org === normalized.scope.org).length >= MAX_RETAINED_INSTALLATIONS_PER_ORG)
+                throw new InstallationCapacityError();
+            const now = this.#now().toISOString();
+            const installation = {
+                scope: { ...normalized.scope },
+                publicId: this.#uniquePublicId(),
+                profileKey: normalized.profileKey,
+                profileVersion: normalized.profileVersion,
+                managedCollections: [...normalized.managedCollections],
+                definition: structuredClone(normalized.definition),
+                retentionDays: normalized.retentionDays,
+                intakeActive: true,
+                applicationGeneration: 'pending',
+                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: effectiveInstallation(installation, this.#managedDefinition),
+            };
+        });
+    }
+    getInstallation(scope) {
+        return this.#lifecycle.getInstallation(scope);
+    }
+    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 : effectiveInstallation(found, this.#managedDefinition));
+    }
+    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 : effectiveInstallation(found, this.#managedDefinition));
+    }
+    listInstallations(org) {
+        return this.#lifecycle.listInstallations(org);
+    }
+    listInstallationsForSubject(subject) {
+        const normalized = validateScalar('identity subject', subject, 256);
+        return Promise.resolve([...this.#grants.values()]
+            .filter((grant) => grant.subject === normalized && grant.revokedAt === undefined)
+            .map((grant) => {
+            const installation = this.#installations.get(scopeKey(grant.scope));
+            if (installation === undefined)
+                throw new Error('business grant installation is missing');
+            return {
+                installation: effectiveInstallation(installation, this.#managedDefinition),
+                grant: cloneGrant(grant),
+            };
+        })
+            .sort((left, right) => left.installation.createdAt.localeCompare(right.installation.createdAt)));
+    }
+    configureApplicationLifecycle(resolve) {
+        this.#lifecycle.configureApplicationLifecycle(resolve);
+    }
+    bindApplication(scope, generation) {
+        return this.#lifecycle.bindApplication(scope, generation);
+    }
+    pauseApplication(org, app, at, retired = false) {
+        return this.#lifecycle.pauseApplication(org, app, at, retired);
+    }
+    setIntakeState(input) {
+        return this.#lifecycle.setIntakeState(input);
+    }
+    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.#locks.run(`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.#locks.run(`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 createInvitation(input) {
+        return this.#invitations.create(input);
+    }
+    listInvitations(scope) {
+        return this.#invitations.list(scope);
+    }
+    async revokeInvitation(input) {
+        return this.#invitations.revoke(input);
+    }
+    async claimInvitation(input) {
+        return this.#invitations.claim(input);
+    }
+    async createRequest(input) {
+        const idempotencyKey = idempotencyDigest(input.idempotencyKey);
+        const key = `${scopeKey(input.scope)}\0${input.collectionKey}\0${idempotencyKey}`;
+        return this.#locks.run(`request-create:${key}`, async () => {
+            return this.#locks.run(`intake:${scopeKey(input.scope)}`, async () => {
+                const installation = await this.#requiredInstallation(input.scope);
+                validateCollectionEnabled(installation, input.collectionKey);
+                const candidate = initialRecord({
+                    installation,
+                    collectionKey: input.collectionKey,
+                    id: this.#id(),
+                    payload: input.payload,
+                    ...(input.publicInput === undefined ? {} : { publicInput: input.publicInput }),
+                    origin: input.origin,
+                    actorSubject: input.actorSubject,
+                    now: this.#now(),
+                });
+                const fingerprint = requestFingerprint({
+                    collectionKey: candidate.collectionKey,
+                    payload: input.payload,
+                    origin: candidate.origin,
+                    actorSubject: candidate.createdBySubject,
+                });
+                const replay = this.#idempotency.get(key);
+                if (replay !== undefined) {
+                    const existing = this.#expireRecordIfNeeded(replay.recordKey, this.#now());
+                    if (existing === undefined)
+                        throw new Error('idempotency record points to a missing request');
+                    validateStoredRecord(installation, existing);
+                    return {
+                        disposition: replay.fingerprint === fingerprint ? 'replayed' : 'conflict',
+                        record: cloneRecord(existing),
+                    };
+                }
+                if (!(await this.#lifecycle.applicationAllows(installation)) ||
+                    ((input.origin.kind === 'embedded' || input.publicInput === true) &&
+                        !installation.intakeActive)) {
+                    return { disposition: 'paused' };
+                }
+                const currentKey = recordKey(input.scope, candidate.collectionKey, candidate.id);
+                this.#commitRecord(currentKey, candidate, 'created');
+                this.#idempotency.set(key, { fingerprint, recordKey: currentKey });
+                return { disposition: 'created', record: cloneRecord(candidate) };
+            });
+        });
+    }
+    async probeRequest(input) {
+        const installation = await this.#requiredInstallation(input.scope);
+        const candidate = initialRecord({
+            installation,
+            collectionKey: input.collectionKey,
+            id: this.#id(),
+            payload: input.payload,
+            ...(input.publicInput === undefined ? {} : { publicInput: input.publicInput }),
+            origin: input.origin,
+            actorSubject: input.actorSubject,
+            now: this.#now(),
+        });
+        const digest = idempotencyDigest(input.idempotencyKey);
+        const key = `${scopeKey(input.scope)}\0${input.collectionKey}\0${digest}`;
+        const replay = this.#idempotency.get(key);
+        if (replay === undefined)
+            return { disposition: 'missing' };
+        const existing = this.#expireRecordIfNeeded(replay.recordKey, this.#now());
+        if (existing === undefined)
+            throw new Error('idempotency record points to a missing request');
+        validateStoredRecord(installation, existing);
+        const fingerprint = requestFingerprint({
+            collectionKey: candidate.collectionKey,
+            payload: input.payload,
+            origin: candidate.origin,
+            actorSubject: candidate.createdBySubject,
+        });
+        return {
+            disposition: replay.fingerprint === fingerprint ? 'replayed' : 'conflict',
+            record: cloneRecord(existing),
+        };
+    }
+    #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 key = recordKey(scope, collection.key, validateScalar('record id', id, 128));
+        const record = this.#expireRecordIfNeeded(key, this.#now());
+        if (record === undefined || (record.deletedAt !== undefined && options.includeDeleted !== true))
+            return undefined;
+        validateStoredRecord(installation, record);
+        return cloneRecord(record);
+    }
+    async listAcceptedSchemaInventory() {
+        const inventory = new Map();
+        for (const record of this.#records.values()) {
+            const identity = {
+                profileKey: record.profileKey,
+                profileVersion: record.profileVersion,
+                collectionKey: record.collectionKey,
+                schemaVersion: record.schemaVersion,
+                schemaDigest: record.schemaDigest,
+            };
+            inventory.set(JSON.stringify(identity), identity);
+            if (record.originalSchema !== undefined) {
+                const original = { ...identity, ...record.originalSchema };
+                inventory.set(JSON.stringify(original), original);
+            }
+        }
+        return [...inventory.entries()]
+            .sort(([left], [right]) => left.localeCompare(right))
+            .map(([, identity]) => ({ ...identity }));
+    }
+    async listRequests(input) {
+        const installation = await this.#requiredInstallation(input.scope);
+        const collection = validateCollectionEnabled(installation, input.collectionKey);
+        const now = this.#now();
+        const plan = await planNativeQuery(input, collection, now, (id) => this.getRequest(input.scope, collection.key, id, { includeDeleted: true }));
+        const records = this.#matchingRecords(input.scope, collection.key).filter((record) => matchesNativeQueryMetadata(record, plan, now));
+        const result = await runNativeQuery(plan, records);
+        for (const record of result.records)
+            validateStoredRecord(installation, record);
+        return result;
+    }
+    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));
+        const mutate = () => this.#locks.run(`request:${key}`, async () => {
+            const current = this.#expireRecordIfNeeded(key, this.#now());
+            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 };
+            }
+            if (input.operation.kind === 'assign' &&
+                !collectionControlEnabled(collection, 'assignment')) {
+                return { ok: false, reason: 'invalid_transition', currentRevision: current.revision };
+            }
+            if (input.operation.kind === 'assign' && input.operation.assigneeSubject !== undefined) {
+                const assignee = this.#grants.get(grantKey(input.scope, input.operation.assigneeSubject));
+                if (assignee === undefined ||
+                    assignee.revokedAt !== undefined ||
+                    assignee.role === 'viewer' ||
+                    !(await this.#principals.allows(assignee.subject))) {
+                    return { ok: false, reason: 'invalid_assignee', currentRevision: current.revision };
+                }
+            }
+            const historicalCollection = validateStoredRecord(installation, current);
+            const applied = applyRequestOperation(current, {
+                ...historicalCollection,
+                ...(collection.management === undefined ? {} : { management: collection.management }),
+                ...(collection.editableFields === undefined
+                    ? {}
+                    : { editableFields: collection.editableFields }),
+            }, input.operation, input.actorSubject, this.#now(), this.#id);
+            if (applied === undefined) {
+                return { ok: false, reason: 'invalid_transition', currentRevision: current.revision };
+            }
+            this.#commitRecord(key, applied.record, applied.activityKind);
+            return { ok: true, record: cloneRecord(applied.record) };
+        });
+        return input.operation.kind === 'assign'
+            ? this.#locks.run(`grants:${scopeKey(input.scope)}`, mutate)
+            : mutate();
+    }
+    async migrateLegacyRequest(input) {
+        validateExpectedRevision(input.expectedRevision);
+        const installation = await this.#requiredInstallation(input.scope);
+        validateCollectionEnabled(installation, input.collectionKey);
+        const key = recordKey(input.scope, input.collectionKey, validateScalar('record id', input.id, 128));
+        return this.#locks.run(`request:${key}`, async () => {
+            const current = this.#expireRecordIfNeeded(key, this.#now());
+            if (current === undefined || current.deletedAt !== undefined)
+                return { ok: false, reason: 'not_found', currentRevision: current?.revision ?? 0 };
+            if (current.revision !== input.expectedRevision)
+                return { ok: false, reason: 'conflict', currentRevision: current.revision };
+            const previous = validateStoredRecord(installation, current);
+            const migrated = migrateLegacyRequestRecord(current, previous, installation, input.actorSubject, this.#now());
+            if (migrated === undefined)
+                return { ok: false, reason: 'invalid_transition', currentRevision: current.revision };
+            if (migrated !== current) {
+                this.#commitRecord(key, migrated, 'schema_migrated');
+            }
+            return { ok: true, record: cloneRecord(migrated) };
+        });
+    }
+    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.#locks.run(`request:${key}`, () => Promise.resolve(this.#eraseRecord(key, input.expectedRevision, input.actorSubject, 'customer_request')));
+    }
+    async listActivity(scope, collectionKey, id, input) {
+        const installation = await this.#requiredInstallation(scope);
+        const collection = validateCollectionEnabled(installation, collectionKey);
+        const key = recordKey(validateScope(scope), collection.key, validateScalar('record id', id, 128));
+        const record = this.#expireRecordIfNeeded(key, this.#now());
+        if (record !== undefined)
+            validateStoredRecord(installation, record);
+        return memoryActivityPage(scope, collection.key, id, this.#activities.get(key) ?? [], input);
+    }
+    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));
+        for (const record of records)
+            validateStoredRecord(installation, record);
+        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.#locks.run(`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`;
+        const now = this.#now().toISOString();
+        return [...this.#records.entries()]
+            .filter(([key, record]) => key.startsWith(prefix) &&
+            (record.deletedAt !== undefined || record.retentionExpiresAt > now))
+            .map(([, record]) => record)
+            .sort(compareRecords);
+    }
+    #expireRecordIfNeeded(key, now) {
+        const current = this.#records.get(key);
+        if (current === undefined ||
+            current.deletedAt !== undefined ||
+            current.retentionExpiresAt > now.toISOString()) {
+            return current;
+        }
+        const erased = deletedRecord(current, 'system:retention', now, 'retention_expired');
+        this.#commitRecord(key, erased, 'retention_expired');
+        return erased;
+    }
+    #eraseRecord(key, expectedRevision, actorSubject, reason) {
+        const current = reason === 'retention_expired'
+            ? this.#records.get(key)
+            : this.#expireRecordIfNeeded(key, this.#now());
+        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.#commitRecord(key, erased, reason === 'customer_request' ? 'deleted' : 'retention_expired');
+        return { ok: true, record: cloneRecord(erased) };
+    }
+    #commitRecord(key, record, kind) {
+        commitNativeMemoryRecord(this.#records, this.#activities, this.#custody, key, record, activityFromRecord(record, kind));
+    }
+    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');
+    }
+}
+//# sourceMappingURL=in-memory-store.js.map

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

@@ -0,0 +1,10 @@
+/** Technical retained-metadata guard, independent of app or commercial entitlements. */
+export const MAX_RETAINED_INSTALLATIONS_PER_ORG = 1_000;
+export class InstallationCapacityError extends Error {
+    code = 'installation_capacity_exceeded';
+    constructor() {
+        super('This organization has reached its retained installation limit. Reuse an existing application and environment; existing installations remain accessible.');
+        this.name = 'InstallationCapacityError';
+    }
+}
+//# sourceMappingURL=installation-capacity.js.map

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

@@ -0,0 +1,68 @@
+import { createHash } from 'node:crypto';
+import { validateExpectedRevision } from './model.js';
+import { validateEmail, validateScalar, validateScope } from './validation.js';
+export function normalizeInvitationInput(input) {
+    const expiresAt = input.expiresAt;
+    if (!Number.isFinite(expiresAt.getTime()))
+        throw new Error('invitation expiry is invalid');
+    const tokenDigest = validateDigest('invitation token digest', input.tokenDigest);
+    const idempotencyDigest = createHash('sha256')
+        .update(validateScalar('invitation idempotency key', input.idempotencyKey, 128))
+        .digest('hex');
+    const normalized = {
+        scope: validateScope(input.scope),
+        invitationId: validateScalar('invitation id', input.invitationId, 128),
+        email: validateEmail(input.email),
+        role: input.role,
+        tokenDigest,
+        idempotencyDigest,
+        expiresAt,
+        actorSubject: validateScalar('actor subject', input.actorSubject, 256),
+    };
+    return {
+        ...normalized,
+        createFingerprint: createHash('sha256')
+            .update(JSON.stringify({
+            scope: normalized.scope,
+            email: normalized.email,
+            role: normalized.role,
+            tokenDigest: normalized.tokenDigest,
+        }))
+            .digest('hex'),
+    };
+}
+export function validateInvitationMutation(input) {
+    validateExpectedRevision(input.expectedRevision);
+    return {
+        scope: validateScope(input.scope),
+        invitationId: validateScalar('invitation id', input.invitationId, 128),
+        expectedRevision: input.expectedRevision,
+        actorSubject: validateScalar('actor subject', input.actorSubject, 256),
+    };
+}
+export function validateInvitationClaim(input) {
+    return {
+        tokenDigest: validateDigest('invitation token digest', input.tokenDigest),
+        subject: validateScalar('identity subject', input.subject, 256),
+        email: validateEmail(input.email),
+    };
+}
+export function invitationStatus(invitation, now) {
+    if (invitation.acceptedAt !== undefined)
+        return 'accepted';
+    if (invitation.revokedAt !== undefined)
+        return 'revoked';
+    if (Date.parse(invitation.expiresAt) <= now.getTime())
+        return 'expired';
+    return 'pending';
+}
+export function cloneInvitation(invitation) {
+    return { ...invitation, scope: { ...invitation.scope } };
+}
+function validateDigest(name, value) {
+    const digest = validateScalar(name, value, 64);
+    if (!/^[a-f0-9]{64}$/.test(digest))
+        throw new Error(`${name} is invalid`);
+    return digest;
+}
+//# sourceMappingURL=invitations.js.map