@noodleseed/one 0.161.2 → 0.163.0

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

@@ -0,0 +1,393 @@
+import { createHash } from 'node:crypto';
+import { projectManagedCollectionControls, validateJsonSchema, validateManagedCollectionControls, } from '@noodle-borg/compiler';
+import { collectionControlEnabled, creationPayload, patchedPayload, } from './collection-controls.js';
+import { collectionForStoredRecord, resolveManagedInstallation, } from './managed-releases.js';
+import { builtInDefinition } from './profiles.js';
+import { PayloadValidationError, validateEmail, validateManagedPayload, validateRetentionDays, validateRevision, validateScalar, validateScope, } from './validation.js';
+const ROLE_PERMISSIONS = {
+    administrator: [
+        'installation:administer',
+        'grants:manage',
+        'records:create',
+        'records:read',
+        'records:update',
+        'records:assign',
+        'records:status',
+        'records:note',
+        'records:delete',
+        'records:export',
+    ],
+    manager: [
+        'records:create',
+        'records:read',
+        'records:update',
+        'records:assign',
+        'records:status',
+        'records:note',
+        'records:export',
+    ],
+    operator: [
+        'records:create',
+        'records:read',
+        'records:update',
+        'records:assign',
+        'records:status',
+        'records:note',
+    ],
+    viewer: ['records:read'],
+};
+export function permissionsForBusinessRole(role) {
+    const permissions = ROLE_PERMISSIONS[role];
+    if (permissions === undefined)
+        throw new Error(`unknown business role "${String(role)}"`);
+    return permissions;
+}
+export function businessGrantAllows(grant, permission) {
+    return (grant !== undefined &&
+        grant.revokedAt === undefined &&
+        permissionsForBusinessRole(grant.role).includes(permission));
+}
+export function normalizeInstallationInput(input) {
+    const scope = { ...validateScope(input.scope) };
+    if ((input.profileKey === undefined) === (input.definition === undefined)) {
+        throw new Error('installation requires exactly one managed profile or private definition');
+    }
+    const definition = input.definition ??
+        builtInDefinition(input.profileKey);
+    validateDefinition(definition);
+    const managedCollections = [...new Set(input.managedCollections)].sort();
+    for (const collectionKey of managedCollections) {
+        if (!definition.collections.some((collection) => collection.key === collectionKey)) {
+            throw new Error(`collection "${collectionKey}" is not declared by the installed definition`);
+        }
+    }
+    const profileKey = input.profileKey ??
+        (definition.reference.kind === 'private'
+            ? definition.reference.app
+            : definition.reference.definitionId);
+    const profileVersion = definition.reference.kind === 'private'
+        ? parseDefinitionVersion(definition.reference.version)
+        : definition.reference.release;
+    return {
+        scope,
+        profileKey,
+        profileVersion,
+        definition: structuredClone(definition),
+        managedCollections,
+        retentionDays: validateRetentionDays(input.retentionDays),
+        actorSubject: validateScalar('actor subject', input.actorSubject, 256),
+        ...(input.actorEmail === undefined ? {} : { actorEmail: validateEmail(input.actorEmail) }),
+    };
+}
+export function installationFingerprint(input) {
+    const definitionIntent = input.definition.reference.kind === 'managed'
+        ? { managedDefinitionId: input.definition.reference.definitionId }
+        : { profileVersion: input.profileVersion, definition: input.definition };
+    return digest({
+        scope: input.scope,
+        profileKey: input.profileKey,
+        ...definitionIntent,
+        managedCollections: input.managedCollections,
+        retentionDays: input.retentionDays,
+        actorSubject: input.actorSubject,
+        ...(input.definition.reference.kind === 'managed' ? {} : { actorEmail: input.actorEmail }),
+    });
+}
+/** Compatibility for rows whose pre-update fingerprint included the resolved managed release. */
+export function managedInstallationIntentMatches(existing, input) {
+    const existingReference = existing.definition.reference;
+    const inputReference = input.definition.reference;
+    return (existingReference.kind === 'managed' &&
+        inputReference.kind === 'managed' &&
+        existingReference.definitionId === inputReference.definitionId &&
+        digest(existing.scope) === digest(input.scope) &&
+        existing.profileKey === input.profileKey &&
+        digest([...existing.managedCollections].sort()) === digest(input.managedCollections) &&
+        existing.retentionDays === input.retentionDays &&
+        existing.createdBySubject === input.actorSubject);
+}
+export function requestFingerprint(input) {
+    return digest(input);
+}
+export function idempotencyDigest(value) {
+    return digest(validateScalar('idempotency key', value, 128));
+}
+export function validateCollectionEnabled(installation, collectionKey) {
+    const normalized = validateScalar('collection key', collectionKey, 64);
+    if (!installation.managedCollections.includes(normalized)) {
+        throw new Error(`managed collection "${normalized}" is not enabled for this installation`);
+    }
+    const collection = installation.definition.collections.find((candidate) => candidate.key === normalized);
+    if (collection === undefined)
+        throw new Error(`managed collection "${normalized}" is missing from the installed definition`);
+    return collection;
+}
+export function initialRecord(input) {
+    const collection = validateCollectionEnabled(input.installation, input.collectionKey);
+    if (collection.authority.authority !== 'native') {
+        throw new Error(`managed collection "${collection.key}" is externally authoritative and read-only`);
+    }
+    const payload = creationPayload(collection, input.payload, input.publicInput === true || input.origin.kind === 'embedded');
+    const actor = validateScalar('actor subject', input.actorSubject, 256);
+    const id = validateScalar('record id', input.id, 128);
+    const createdAt = input.now.toISOString();
+    return {
+        scope: { ...input.installation.scope },
+        collectionKey: collection.key,
+        id,
+        profileKey: input.installation.profileKey,
+        profileVersion: input.installation.profileVersion,
+        schemaVersion: collection.schemaVersion,
+        schemaDigest: collection.schemaDigest,
+        ...(collection.behavior?.kind === 'request' ? { status: 'new' } : {}),
+        origin: normalizeOrigin(input.origin),
+        revision: 1,
+        retentionExpiresAt: new Date(input.now.getTime() + input.installation.retentionDays * 24 * 60 * 60 * 1000).toISOString(),
+        createdAt,
+        createdBySubject: actor,
+        updatedAt: createdAt,
+        updatedBySubject: actor,
+        content: { payload, notes: [] },
+    };
+}
+export function applyRequestOperation(current, collection, operation, actorSubject, now, noteId) {
+    if (current.deletedAt !== undefined || current.content === undefined)
+        return undefined;
+    if (collection.authority.authority !== 'native')
+        return undefined;
+    const actor = validateScalar('actor subject', actorSubject, 256);
+    const revision = current.revision + 1;
+    const updatedAt = now.toISOString();
+    if (operation.kind === 'update') {
+        const payload = validateCollectionPayload(collection, patchedPayload(collection, current.content.payload, operation.payload, operation.unset));
+        return {
+            record: cloneRecord({
+                ...current,
+                revision,
+                updatedAt,
+                updatedBySubject: actor,
+                content: { payload, notes: current.content.notes },
+            }),
+            activityKind: 'updated',
+        };
+    }
+    if (operation.kind === 'assign') {
+        if (!collectionControlEnabled(collection, 'assignment'))
+            return undefined;
+        const assignee = operation.assigneeSubject === undefined
+            ? undefined
+            : validateScalar('assignee subject', operation.assigneeSubject, 256);
+        const { assigneeSubject: ignoredAssignee, ...withoutAssignee } = current;
+        void ignoredAssignee;
+        return {
+            record: cloneRecord({
+                ...withoutAssignee,
+                ...(assignee === undefined ? {} : { assigneeSubject: assignee }),
+                revision,
+                updatedAt,
+                updatedBySubject: actor,
+            }),
+            activityKind: 'assigned',
+        };
+    }
+    if (operation.kind === 'set_status') {
+        if (collection.behavior?.kind !== 'request' || current.status === undefined)
+            return undefined;
+        if (!validStatusTransition(current.status, operation.status))
+            return undefined;
+        return {
+            record: cloneRecord({
+                ...current,
+                status: operation.status,
+                revision,
+                updatedAt,
+                updatedBySubject: actor,
+            }),
+            activityKind: 'status_changed',
+        };
+    }
+    if (!collectionControlEnabled(collection, 'notes'))
+        return undefined;
+    const note = validateNote(operation.note);
+    if (current.content.notes.length >= 50)
+        throw new PayloadValidationError('array_too_large', 'A record cannot have more than 50 notes.');
+    return {
+        record: cloneRecord({
+            ...current,
+            revision,
+            updatedAt,
+            updatedBySubject: actor,
+            content: {
+                payload: current.content.payload,
+                notes: [
+                    ...current.content.notes,
+                    {
+                        id: validateScalar('note id', noteId(), 128),
+                        text: note,
+                        createdAt: updatedAt,
+                        createdBySubject: actor,
+                    },
+                ],
+            },
+        }),
+        activityKind: 'note_added',
+    };
+}
+export function validateStoredRecord(installation, record) {
+    const collection = collectionForStoredRecord(installation, record);
+    if (record.content !== undefined)
+        validateCollectionPayload(collection, record.content.payload);
+    return collection;
+}
+export function deletedRecord(current, actorSubject, now, reason) {
+    const actor = validateScalar('actor subject', actorSubject, 256);
+    const deletedAt = now.toISOString();
+    const { content: ignoredContent, ...metadata } = current;
+    void ignoredContent;
+    return cloneRecord({
+        ...metadata,
+        origin: { kind: current.origin.kind },
+        revision: current.revision + 1,
+        updatedAt: deletedAt,
+        updatedBySubject: actor,
+        deletedAt,
+        deletionReason: reason,
+    });
+}
+export function activityFromRecord(record, kind) {
+    return {
+        scope: { ...record.scope },
+        collectionKey: record.collectionKey,
+        recordId: record.id,
+        revision: record.revision,
+        kind,
+        ...(record.status === undefined ? {} : { status: record.status }),
+        ...(record.assigneeSubject === undefined ? {} : { assigneeSubject: record.assigneeSubject }),
+        occurredAt: record.updatedAt,
+        actorSubject: record.updatedBySubject,
+        ...(record.content === undefined ? {} : { content: cloneContent(record.content) }),
+    };
+}
+export function cloneRecord(record) {
+    return {
+        ...record,
+        ...(record.originalSchema === undefined
+            ? {}
+            : { originalSchema: { ...record.originalSchema } }),
+        scope: { ...record.scope },
+        origin: { ...record.origin },
+        ...(record.content === undefined ? {} : { content: cloneContent(record.content) }),
+    };
+}
+export function cloneContent(content) {
+    return {
+        payload: structuredClone(content.payload),
+        notes: content.notes.map((note) => ({ ...note })),
+    };
+}
+export function cloneInstallation(installation) {
+    return {
+        ...installation,
+        scope: { ...installation.scope },
+        managedCollections: [...installation.managedCollections],
+        definition: structuredClone(installation.definition),
+    };
+}
+/**
+ * Managed verticals are one centrally released application definition. Existing installations keep
+ * identity, grants, records and retention while compatible catalog releases update their effective
+ * collections for every customer on the next read. Private and legacy definitions stay pinned.
+ */
+export function effectiveInstallation(installation, resolveCurrent) {
+    return resolveManagedInstallation(installation, resolveCurrent);
+}
+export function cloneGrant(grant) {
+    return { ...grant, scope: { ...grant.scope } };
+}
+export function cloneActivity(activity) {
+    return {
+        ...activity,
+        scope: { ...activity.scope },
+        ...(activity.content === undefined ? {} : { content: cloneContent(activity.content) }),
+    };
+}
+export function validateExpectedRevision(value) {
+    return validateRevision(value);
+}
+function normalizeOrigin(origin) {
+    const kinds = ['embedded', 'mcp', 'portal', 'api', 'import'];
+    if (!kinds.includes(origin.kind))
+        throw new Error('unsupported managed request origin');
+    return {
+        kind: origin.kind,
+        ...(origin.reference === undefined
+            ? {}
+            : { reference: validateScalar('origin reference', origin.reference, 256) }),
+    };
+}
+function validateNote(note) {
+    const normalized = note.trim();
+    if (!normalized || normalized.length > 4_000 || normalized.includes('\0'))
+        throw new PayloadValidationError('string_too_long', 'A note must contain 1 to 4,000 characters.');
+    validateManagedPayload({ note: normalized });
+    return normalized;
+}
+function validStatusTransition(from, to) {
+    if (from === to)
+        return true;
+    if (from === 'closed')
+        return false;
+    if (from === 'resolved')
+        return to === 'in_progress' || to === 'closed';
+    return to === 'new' || to === 'in_progress' || to === 'resolved' || to === 'closed';
+}
+export function validateCollectionPayload(collection, value) {
+    const payload = validateManagedPayload(value);
+    const issues = validateJsonSchema(collection.recordSchema, payload);
+    if (issues.length > 0) {
+        throw new PayloadValidationError('invalid_json', `managed payload does not match collection schema: ${issues[0]?.message ?? 'invalid value'}`);
+    }
+    return payload;
+}
+function validateDefinition(definition) {
+    validateScalar('definition title', definition.title, 120);
+    validateScalar('definition description', definition.description, 1000);
+    if (definition.collections.length > 16) {
+        throw new Error('definition may declare at most sixteen collections');
+    }
+    const keys = new Set();
+    for (const collection of definition.collections) {
+        const issues = [];
+        validateManagedCollectionControls(projectManagedCollectionControls(collection), collection.recordSchema, collection.authority.authority === 'external', `collections.${collection.key}`, issues);
+        if (issues.length > 0)
+            throw new Error(issues[0]?.message ?? 'invalid collection controls');
+        validateScalar('collection key', collection.key, 64);
+        if (keys.has(collection.key))
+            throw new Error(`duplicate collection "${collection.key}"`);
+        keys.add(collection.key);
+        if (!/^[a-f0-9]{64}$/.test(collection.schemaDigest.replace(/^sha256:/, ''))) {
+            throw new Error(`collection "${collection.key}" has an invalid schema digest`);
+        }
+    }
+}
+function parseDefinitionVersion(version) {
+    const [major] = version.split('.');
+    const parsed = Number(major);
+    return Number.isSafeInteger(parsed) && parsed > 0 ? parsed : 1;
+}
+function digest(value) {
+    return createHash('sha256').update(stableJson(value)).digest('hex');
+}
+function stableJson(value) {
+    if (Array.isArray(value))
+        return `[${value.map(stableJson).join(',')}]`;
+    if (value !== null && typeof value === 'object') {
+        return `{${Object.entries(value)
+            .filter(([, entry]) => entry !== undefined)
+            .sort(([left], [right]) => left.localeCompare(right))
+            .map(([key, entry]) => `${JSON.stringify(key)}:${stableJson(entry)}`)
+            .join(',')}}`;
+    }
+    return JSON.stringify(value);
+}
+//# sourceMappingURL=model.js.map

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

@@ -0,0 +1,162 @@
+import { createHash } from 'node:crypto';
+import { canonicalJson, validateJsonSchema } from '@noodle-borg/compiler';
+import { MANAGED_RECORD_QUERY_SCAN_LIMIT, ManagedRecordQuerySchema, } from '@noodle-borg/wire-contracts';
+import { cloneRecord } from './model.js';
+import { compareRecords, scopeKey } from './pagination.js';
+import { boundedPageSize, CursorValidationError } from './validation.js';
+export class NativeQueryError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+    }
+}
+export async function planNativeQuery(input, collection, now, loadAnchor) {
+    const parsed = ManagedRecordQuerySchema.safeParse({
+        ...(input.filters === undefined ? {} : { filters: input.filters }),
+        ...(input.sortField === undefined ? {} : { sortField: input.sortField }),
+        ...(input.sortDirection === undefined ? {} : { sortDirection: input.sortDirection }),
+        ...(input.createdAtFrom === undefined ? {} : { createdAtFrom: input.createdAtFrom }),
+        ...(input.createdAtTo === undefined ? {} : { createdAtTo: input.createdAtTo }),
+    });
+    if (!parsed.success)
+        throw new NativeQueryError('invalid_query', 'Invalid bounded collection query.');
+    const properties = collection.recordSchema.properties;
+    for (const filter of parsed.data.filters ?? []) {
+        if (!collection.filterFields?.includes(filter.field))
+            throw new NativeQueryError('invalid_query', 'Filter field must be declared in filterFields.');
+        if (validateJsonSchema(properties?.[filter.field], filter.value)
+            .length > 0)
+            throw new NativeQueryError('invalid_query', 'Filter value must match its field schema.');
+    }
+    if (input.sortField !== undefined && !collection.sortFields?.includes(input.sortField))
+        throw new NativeQueryError('invalid_query', 'Sort field must be declared in sortFields.');
+    const normalized = {
+        ...input,
+        filters: [...(parsed.data.filters ?? [])].sort((a, b) => a.field.localeCompare(b.field)),
+        ...(input.sortField === undefined
+            ? {}
+            : { sortDirection: input.sortDirection ?? 'asc' }),
+        ...(input.createdAtFrom === undefined
+            ? {}
+            : { createdAtFrom: new Date(input.createdAtFrom).toISOString() }),
+        ...(input.createdAtTo === undefined
+            ? {}
+            : { createdAtTo: new Date(input.createdAtTo).toISOString() }),
+    };
+    const limit = boundedPageSize(input.limit);
+    const digest = createHash('sha256')
+        .update(canonicalJson({
+        scope: scopeKey(input.scope),
+        collection: collection.key,
+        schema: collection.schemaDigest,
+        filters: normalized.filters,
+        sortField: input.sortField ?? null,
+        sortDirection: normalized.sortDirection ?? null,
+        createdAtFrom: normalized.createdAtFrom ?? null,
+        createdAtTo: normalized.createdAtTo ?? null,
+        status: input.status ?? null,
+        assigneeSubject: input.assigneeSubject ?? null,
+        includeDeleted: input.includeDeleted === true,
+    }))
+        .digest('hex');
+    const cursor = input.cursor === undefined ? undefined : readQueryCursor(input.cursor, digest, now);
+    const anchor = cursor === undefined ? undefined : await loadAnchor(cursor.lastId);
+    if (cursor !== undefined && (anchor === undefined || anchor.revision !== cursor.lastRevision))
+        throw new CursorValidationError('cursor anchor changed or was deleted; restart this query');
+    return {
+        input: normalized,
+        limit,
+        digest,
+        payloadQuery: normalized.filters.length > 0 || input.sortField !== undefined,
+        snapshotAt: cursor?.snapshotAt ?? now.toISOString(),
+        ...(anchor === undefined ? {} : { anchor }),
+    };
+}
+function readQueryCursor(encoded, digest, now) {
+    try {
+        if (encoded.length > 2048)
+            throw new Error();
+        const value = JSON.parse(Buffer.from(encoded, 'base64url').toString());
+        if (value === null || typeof value !== 'object')
+            throw new Error();
+        const cursor = value;
+        if (cursor.version !== 2 ||
+            cursor.digest !== digest ||
+            typeof cursor.lastId !== 'string' ||
+            cursor.lastId.length > 128 ||
+            typeof cursor.lastRevision !== 'number' ||
+            !Number.isSafeInteger(cursor.lastRevision) ||
+            cursor.lastRevision < 1 ||
+            typeof cursor.snapshotAt !== 'string' ||
+            !Number.isFinite(Date.parse(cursor.snapshotAt)) ||
+            Date.parse(cursor.snapshotAt) > now.getTime())
+            throw new Error();
+        return cursor;
+    }
+    catch {
+        throw new CursorValidationError('cursor does not belong to this query and schema');
+    }
+}
+export function matchesNativeQueryMetadata(record, plan, now) {
+    const input = plan.input;
+    return (scopeKey(record.scope) === scopeKey(input.scope) &&
+        record.collectionKey === input.collectionKey &&
+        (input.includeDeleted === true || record.deletedAt === undefined) &&
+        (record.deletedAt !== undefined || record.retentionExpiresAt > now.toISOString()) &&
+        (input.status === undefined || record.status === input.status) &&
+        (input.assigneeSubject === undefined || record.assigneeSubject === input.assigneeSubject) &&
+        record.createdAt <= plan.snapshotAt &&
+        (input.createdAtFrom === undefined || record.createdAt >= input.createdAtFrom) &&
+        (input.createdAtTo === undefined || record.createdAt <= input.createdAtTo));
+}
+/** Source is already scoped/date filtered and createdAt/id ordered; retains only page + one candidates. */
+export async function runNativeQuery(plan, source) {
+    const selected = [];
+    let scanned = 0;
+    for await (const record of source) {
+        if (plan.payloadQuery && ++scanned > MANAGED_RECORD_QUERY_SCAN_LIMIT)
+            throw new NativeQueryError('query_limit_exceeded', 'This query exceeds 10,000 scanned records. Narrow createdAtFrom/createdAtTo and retry.');
+        if (!plan.input.filters?.every((filter) => record.content?.payload[filter.field] === filter.value))
+            continue;
+        if (plan.anchor !== undefined && compareQueryRecords(record, plan.anchor, plan) <= 0)
+            continue;
+        selected.push(record);
+        selected.sort((a, b) => compareQueryRecords(a, b, plan));
+        if (selected.length > plan.limit + 1)
+            selected.pop();
+        if (!plan.payloadQuery && selected.length > plan.limit)
+            break;
+    }
+    const records = selected.slice(0, plan.limit).map(cloneRecord);
+    const last = records.at(-1);
+    return {
+        records,
+        ...(selected.length > plan.limit && last !== undefined
+            ? {
+                nextCursor: Buffer.from(JSON.stringify({
+                    version: 2,
+                    digest: plan.digest,
+                    snapshotAt: plan.snapshotAt,
+                    lastId: last.id,
+                    lastRevision: last.revision,
+                })).toString('base64url'),
+            }
+            : {}),
+    };
+}
+function compareQueryRecords(a, b, plan) {
+    const field = plan.input.sortField;
+    if (field === undefined)
+        return compareRecords(a, b);
+    const left = a.content?.payload[field];
+    const right = b.content?.payload[field];
+    // Missing historical/optional fields sort last in both directions.
+    if (left === undefined || left === null)
+        return right === undefined || right === null ? compareRecords(a, b) : 1;
+    if (right === undefined || right === null)
+        return -1;
+    const compared = left === right ? 0 : left < right ? -1 : 1;
+    return (plan.input.sortDirection === 'desc' ? -compared : compared) || compareRecords(a, b);
+}
+//# sourceMappingURL=native-query.js.map

package/node_modules/@noodle-borg/service/dist/business-information/native-storage-budget.js

@@ -0,0 +1,60 @@
+/** Engineering bound, not a commercial storage allowance or estimate of disk/WAL usage. */
+export const NATIVE_RETAINED_BYTES_LIMIT = 1024 ** 3;
+/** Prepaid by every live record; funds the bounded terminal receipt even at the ceiling. */
+export const NATIVE_TERMINAL_RESERVE_BYTES = 16 * 1024;
+export class NativeStorageLimitError extends Error {
+    code = 'managed_record_storage_limit';
+    constructor() {
+        super('Managed record storage is full. Erase retained records to reclaim capacity.');
+        this.name = 'NativeStorageLimitError';
+    }
+}
+/** Local/test accounting uses its plaintext serialized representation; PostgreSQL counts ciphertext. */
+export function nativeCustodyBytes(value) {
+    return (Buffer.byteLength(JSON.stringify(value), 'utf8') +
+        ('retentionExpiresAt' in value && value.deletedAt === undefined
+            ? NATIVE_TERMINAL_RESERVE_BYTES
+            : 0));
+}
+export class NativeStorageBudget {
+    maximum;
+    #totals = new Map();
+    constructor(maximum = NATIVE_RETAINED_BYTES_LIMIT) {
+        this.maximum = maximum;
+    }
+    replace(scope, previousBytes, nextBytes) {
+        const current = this.#totals.get(scope) ?? 0;
+        const delta = nextBytes - previousBytes;
+        const next = current + delta;
+        if (!Number.isSafeInteger(next) || next < 0)
+            throw new Error('Invalid native custody accounting');
+        if (delta > 0 && next > this.maximum)
+            throw new NativeStorageLimitError();
+        this.#totals.set(scope, next);
+    }
+}
+/** Commit checks precede every map mutation, including history and the caller's idempotency insert. */
+export function commitNativeMemoryRecord(records, activities, budget, key, record, activity) {
+    const previous = records.get(key);
+    const history = activities.get(key) ?? [];
+    let previousBytes = previous === undefined ? 0 : nativeCustodyBytes(previous);
+    let nextBytes = nativeCustodyBytes(record) + nativeCustodyBytes(activity);
+    let retainedHistory = history;
+    if (record.deletedAt !== undefined) {
+        retainedHistory = history.map((entry) => {
+            const { content: ignored, ...metadata } = entry;
+            void ignored;
+            previousBytes += nativeCustodyBytes(entry);
+            nextBytes += nativeCustodyBytes(metadata);
+            return metadata;
+        });
+    }
+    const scope = record.scope;
+    budget.replace(`${scope.org}\0${scope.app}\0${scope.env}\0${scope.installationId}`, previousBytes, nextBytes);
+    records.set(key, record);
+    if (retainedHistory !== history || previous === undefined)
+        activities.set(key, [...retainedHistory, activity]);
+    else
+        history.push(activity);
+}
+//# sourceMappingURL=native-storage-budget.js.map