@noodleseed/one 0.161.2 → 0.163.0

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

@@ -0,0 +1,78 @@
+import { cloneRecord } from './model.js';
+import { CursorValidationError, validateScalar } from './validation.js';
+export function scopeKey(scope) {
+    return `${scope.org}\0${scope.app}\0${scope.env}\0${scope.installationId}`;
+}
+export function recordKey(scope, collectionKey, id) {
+    return `${scopeKey(scope)}\0${collectionKey}\0${id}`;
+}
+export function encodeCursor(value) {
+    return Buffer.from(JSON.stringify(value), 'utf8').toString('base64url');
+}
+export function decodeCursor(cursor, expected) {
+    let parsed;
+    try {
+        parsed = JSON.parse(Buffer.from(validateScalar('cursor', cursor, 2048), 'base64url').toString('utf8'));
+    }
+    catch {
+        throw new CursorValidationError();
+    }
+    if (!isCursor(parsed))
+        throw new CursorValidationError();
+    if (parsed.kind !== expected.kind ||
+        parsed.scope !== scopeKey(expected.scope) ||
+        parsed.collectionKey !== expected.collectionKey) {
+        throw new CursorValidationError('cursor does not belong to this request scope');
+    }
+    return parsed;
+}
+export function afterCursor(record, cursor) {
+    return (record.createdAt > cursor.lastCreatedAt ||
+        (record.createdAt === cursor.lastCreatedAt && record.id > cursor.lastId));
+}
+export function compareRecords(left, right) {
+    return left.createdAt.localeCompare(right.createdAt) || left.id.localeCompare(right.id);
+}
+function isCursor(value) {
+    if (typeof value !== 'object' || value === null)
+        return false;
+    const input = value;
+    return (input.version === 1 &&
+        (input.kind === 'list' || input.kind === 'export') &&
+        typeof input.scope === 'string' &&
+        typeof input.collectionKey === 'string' &&
+        validTimestamp(input.lastCreatedAt) &&
+        typeof input.lastId === 'string' &&
+        (input.snapshotAt === undefined || validTimestamp(input.snapshotAt)));
+}
+function validTimestamp(value) {
+    return typeof value === 'string' && Number.isFinite(Date.parse(value));
+}
+export 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 }),
+                }),
+            }
+            : {}),
+    };
+}
+export function installationIdKey(org, installationId) {
+    return `${org}\0${installationId}`;
+}
+export function grantKey(scope, subject) {
+    return `${scopeKey(scope)}\0${validateScalar('grant subject', subject, 256)}`;
+}
+//# sourceMappingURL=pagination.js.map

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

@@ -0,0 +1,15 @@
+export * from './collection-controls.js';
+export * from './contracts.js';
+export * from './definition-resolver.js';
+export * from './in-memory-store.js';
+export * from './legacy-request-migration.js';
+export * from './managed-releases.js';
+export * from './model.js';
+export * from './profiles.js';
+export * from './reader-floor.js';
+export * from './source-executor.js';
+export * from './source-ingestion-contracts.js';
+export * from './source-ingestion-coordinator.js';
+export * from './source-ingestion-memory-store.js';
+export * from './validation.js';
+//# sourceMappingURL=portable.js.map

package/node_modules/@noodle-borg/service/dist/business-information/principal-authority.d.ts

@@ -0,0 +1,11 @@
+import { type ModuleSqlTransaction, type PlatformHumanIdentityContribution } from '@noodle-borg/module';
+import type { BusinessGrant } from './contracts.js';
+export type BusinessPrincipalProvider = Pick<PlatformHumanIdentityContribution, 'principalResolver' | 'assertActivePrincipal'>;
+/** Uses the host's canonical authority; it never creates a second principal status store. */
+export declare class BusinessPrincipalAuthority {
+    #private;
+    configure(provider: BusinessPrincipalProvider | undefined): void;
+    allows(subject: string, transaction?: ModuleSqlTransaction): Promise<boolean>;
+    eligible(grants: readonly BusinessGrant[]): Promise<readonly BusinessGrant[]>;
+}
+//# sourceMappingURL=principal-authority.d.ts.map

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

@@ -0,0 +1,42 @@
+import { PlatformIdentityError, } from '@noodle-borg/module';
+/** Uses the host's canonical authority; it never creates a second principal status store. */
+export class BusinessPrincipalAuthority {
+    #provider;
+    configure(provider) {
+        this.#provider = provider;
+    }
+    async allows(subject, transaction) {
+        const provider = this.#provider;
+        if (provider === undefined)
+            return true;
+        try {
+            if (transaction === undefined)
+                await provider.principalResolver.assertActive(subject);
+            else {
+                if (provider.assertActivePrincipal === undefined) {
+                    throw new Error('Business assignment requires transactional principal authority');
+                }
+                await provider.assertActivePrincipal(transaction, subject);
+            }
+            return true;
+        }
+        catch (error) {
+            if (error instanceof PlatformIdentityError && error.code === 'principal_suspended') {
+                return false;
+            }
+            throw error;
+        }
+    }
+    async eligible(grants) {
+        const result = [];
+        for (const grant of grants) {
+            if (grant.revokedAt === undefined &&
+                grant.role !== 'viewer' &&
+                grant.email !== undefined &&
+                (await this.allows(grant.subject)))
+                result.push(grant);
+        }
+        return result;
+    }
+}
+//# sourceMappingURL=principal-authority.js.map

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

@@ -0,0 +1,252 @@
+import { createHash } from 'node:crypto';
+import { managedSolutionBlueprint, managedSolutionVariables, } from './managed-solution-blueprints.js';
+import { PayloadValidationError, validateManagedPayload, validateScalar } from './validation.js';
+const requestSchema = (required, properties) => ({
+    $schema: 'https://json-schema.org/draft/2020-12/schema',
+    type: 'object',
+    additionalProperties: false,
+    required,
+    properties,
+});
+function collection(key, labels, schema, schemaVersion = 1) {
+    return {
+        key,
+        schemaVersion,
+        schemaDigest: createHash('sha256').update(stableJson(schema)).digest('hex'),
+        labels,
+        schema,
+    };
+}
+const travelV1 = collection('travel_requests', { singular: 'Travel request', plural: 'Travel requests', navigation: 'Requests' }, requestSchema(['request_type', 'summary'], {
+    request_type: {
+        type: 'string',
+        enum: ['service', 'cancellation', 'refund', 'recovery'],
+        maxLength: 32,
+    },
+    summary: { type: 'string', minLength: 1, maxLength: 2000 },
+    booking_reference: { type: 'string', maxLength: 128 },
+    traveler_reference: { type: 'string', maxLength: 128 },
+}));
+const travelV2 = collection('travel_requests', { singular: 'Travel request', plural: 'Travel requests', navigation: 'Requests' }, requestSchema(['request_type', 'summary'], {
+    request_type: {
+        type: 'string',
+        enum: ['service', 'cancellation', 'refund', 'recovery', 'information'],
+        maxLength: 32,
+    },
+    summary: { type: 'string', minLength: 1, maxLength: 2000 },
+    booking_reference: { type: 'string', maxLength: 128 },
+    traveler_reference: { type: 'string', maxLength: 128 },
+    priority: { type: 'string', enum: ['normal', 'urgent'], maxLength: 16 },
+}), 2);
+const service = collection('service_requests', { singular: 'Service request', plural: 'Service requests', navigation: 'Requests' }, requestSchema(['request_type', 'summary'], {
+    request_type: {
+        type: 'string',
+        enum: ['support', 'access', 'configuration', 'recovery'],
+        maxLength: 32,
+    },
+    summary: { type: 'string', minLength: 1, maxLength: 2000 },
+    account_reference: { type: 'string', maxLength: 128 },
+    workspace_reference: { type: 'string', maxLength: 128 },
+}));
+const ecommerce = collection('return_requests', { singular: 'Return request', plural: 'Return requests', navigation: 'Returns' }, requestSchema(['order_reference', 'reason'], {
+    order_reference: { type: 'string', minLength: 1, maxLength: 128 },
+    reason: { type: 'string', minLength: 1, maxLength: 2000 },
+    item_reference: { type: 'string', maxLength: 128 },
+    requested_resolution: {
+        type: 'string',
+        enum: ['refund', 'exchange', 'store_credit', 'support'],
+        maxLength: 32,
+    },
+}));
+const restaurant = collection('guest_requests', { singular: 'Guest request', plural: 'Guest requests', navigation: 'Guest requests' }, requestSchema(['request_type', 'summary'], {
+    request_type: {
+        type: 'string',
+        enum: ['reservation_help', 'order_help', 'feedback', 'recovery'],
+        maxLength: 32,
+    },
+    summary: { type: 'string', minLength: 1, maxLength: 2000 },
+    location_reference: { type: 'string', maxLength: 128 },
+    reservation_reference: { type: 'string', maxLength: 128 },
+}));
+export const BUILT_IN_SOLUTION_PROFILE_RELEASES = {
+    travel: [
+        { key: 'travel', version: 1, label: 'Travel', collections: [travelV1] },
+        { key: 'travel', version: 2, label: 'Travel', collections: [travelV2] },
+        { key: 'travel', version: 3, label: 'Travel', collections: [lightweightCollection(travelV2)] },
+    ],
+    b2b_saas: [{ key: 'b2b_saas', version: 1, label: 'B2B SaaS', collections: [service] }],
+    ecommerce: [
+        { key: 'ecommerce', version: 1, label: 'Ecommerce', collections: [ecommerce] },
+        {
+            key: 'ecommerce',
+            version: 2,
+            label: 'Ecommerce',
+            collections: [lightweightCollection(ecommerce)],
+        },
+    ],
+    restaurant: [
+        { key: 'restaurant', version: 1, label: 'Restaurant', collections: [restaurant] },
+        {
+            key: 'restaurant',
+            version: 2,
+            label: 'Restaurant',
+            collections: [lightweightCollection(restaurant)],
+        },
+    ],
+};
+export const BUILT_IN_SOLUTION_PROFILES = {
+    travel: currentProfile('travel'),
+    b2b_saas: { key: 'b2b_saas', version: 1, label: 'B2B SaaS', collections: [service] },
+    ecommerce: currentProfile('ecommerce'),
+    restaurant: currentProfile('restaurant'),
+};
+/** Public managed catalog. The legacy SaaS request profile remains readable but cannot be newly sold. */
+export const MANAGED_SOLUTION_PROFILE_KEYS = ['travel', 'ecommerce', 'restaurant'];
+export function builtInProfile(key) {
+    const profile = BUILT_IN_SOLUTION_PROFILES[key];
+    if (profile === undefined)
+        throw new Error(`unknown built-in solution profile "${String(key)}"`);
+    return profile;
+}
+export function builtInProfileAtRelease(key, release) {
+    const profile = BUILT_IN_SOLUTION_PROFILE_RELEASES[key].find((candidate) => candidate.version === release);
+    if (profile === undefined) {
+        throw new Error(`unsupported built-in solution profile release "${key}@${release}"`);
+    }
+    return profile;
+}
+export function isBuiltInProfileKey(value) {
+    return (value === 'travel' || value === 'b2b_saas' || value === 'ecommerce' || value === 'restaurant');
+}
+export function builtInCollection(profileKey, collectionKey) {
+    const normalized = validateScalar('collection key', collectionKey, 64);
+    const found = builtInProfile(profileKey).collections.find((candidate) => candidate.key === normalized);
+    if (found === undefined) {
+        throw new Error(`collection "${normalized}" is not declared by profile "${profileKey}"`);
+    }
+    return found;
+}
+export function validateProfilePayload(profileKey, collectionKey, value) {
+    const payload = validateManagedPayload(value);
+    const collectionProfile = builtInCollection(profileKey, collectionKey);
+    validateJsonSchema(collectionProfile.schema, payload);
+    return payload;
+}
+export function builtInDefinition(key) {
+    return definitionFromProfile(builtInProfile(key));
+}
+export function builtInDefinitionAtRelease(key, release) {
+    return definitionFromProfile(builtInProfileAtRelease(key, release));
+}
+function definitionFromProfile(profile) {
+    const { key } = profile;
+    const blueprint = managedSolutionBlueprint(key, profile.version);
+    const variables = blueprint === undefined ? undefined : managedSolutionVariables();
+    const digest = createHash('sha256')
+        .update(stableJson({
+        key: profile.key,
+        version: profile.version,
+        collections: profile.collections,
+        ...(blueprint === undefined ? {} : { blueprint, variables }),
+    }))
+        .digest('hex');
+    return {
+        reference: key === 'b2b_saas'
+            ? { kind: 'legacy', definitionId: 'b2b_saas', release: profile.version, digest }
+            : {
+                kind: 'managed',
+                definitionId: key,
+                release: profile.version,
+                digest,
+            },
+        title: profile.label,
+        description: `Receive and operate ${profile.collections[0]?.labels.plural.toLowerCase() ?? 'business records'}.`,
+        collections: profile.collections.map(collectionDefinition),
+        ...(variables === undefined ? {} : { variables }),
+    };
+}
+function currentProfile(key) {
+    const releases = BUILT_IN_SOLUTION_PROFILE_RELEASES[key];
+    const profile = releases.at(-1);
+    if (profile === undefined)
+        throw new Error(`built-in solution profile "${key}" has no releases`);
+    return profile;
+}
+function collectionDefinition(profile) {
+    return {
+        key: profile.key,
+        title: profile.labels.plural,
+        singularTitle: profile.labels.singular,
+        description: `Managed ${profile.labels.plural.toLowerCase()} for this application.`,
+        schemaVersion: profile.schemaVersion,
+        schemaDigest: profile.schemaDigest,
+        recordSchema: structuredClone(profile.schema),
+        summaryFields: profile.schema.required.slice(0, 6),
+        authority: { authority: 'native' },
+        ...(profile.management === undefined
+            ? { behavior: { kind: 'request' } }
+            : {
+                management: profile.management,
+                publicFields: profile.publicFields ?? [],
+                editableFields: Object.keys(profile.schema.properties),
+                fields: { status: { label: 'Status' } },
+                filterFields: ['status'],
+                sortFields: ['status'],
+            }),
+    };
+}
+function lightweightCollection(previous) {
+    return {
+        ...collection(previous.key, previous.labels, {
+            ...previous.schema,
+            properties: {
+                ...previous.schema.properties,
+                status: {
+                    type: 'string',
+                    enum: ['new', 'in_progress', 'resolved', 'closed'],
+                    maxLength: 32,
+                    default: 'new',
+                },
+            },
+        }, previous.schemaVersion + 1),
+        management: { assignment: true, notes: true },
+        publicFields: Object.keys(previous.schema.properties),
+    };
+}
+function validateJsonSchema(schema, payload) {
+    for (const required of schema.required) {
+        if (!(required in payload)) {
+            throw new PayloadValidationError('invalid_json', `managed payload requires "${required}"`);
+        }
+    }
+    for (const [key, value] of Object.entries(payload)) {
+        const property = schema.properties[key];
+        if (property === undefined) {
+            throw new PayloadValidationError('invalid_json', `managed payload field "${key}" is undeclared`);
+        }
+        if (typeof value !== 'string') {
+            throw new PayloadValidationError('invalid_json', `managed payload field "${key}" must be a string`);
+        }
+        if (property.minLength !== undefined && value.length < property.minLength) {
+            throw new PayloadValidationError('invalid_json', `managed payload field "${key}" is too short`);
+        }
+        if (value.length > property.maxLength) {
+            throw new PayloadValidationError('invalid_json', `managed payload field "${key}" is too long`);
+        }
+        if (property.enum !== undefined && !property.enum.includes(value)) {
+            throw new PayloadValidationError('invalid_json', `managed payload field "${key}" has an unsupported value`);
+        }
+    }
+}
+function stableJson(value) {
+    if (Array.isArray(value))
+        return `[${value.map(stableJson).join(',')}]`;
+    if (value !== null && typeof value === 'object') {
+        return `{${Object.entries(value)
+            .sort(([left], [right]) => left.localeCompare(right))
+            .map(([key, entry]) => `${JSON.stringify(key)}:${stableJson(entry)}`)
+            .join(',')}}`;
+    }
+    return JSON.stringify(value);
+}
+//# sourceMappingURL=profiles.js.map

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

@@ -0,0 +1,26 @@
+import { createHash } from 'node:crypto';
+import { assertManagedRollbackReaders } from './managed-releases.js';
+import { builtInDefinition, MANAGED_SOLUTION_PROFILE_KEYS } from './profiles.js';
+/** Proves the running release can read every managed schema identity ever accepted by the store. */
+export async function proveManagedReaderFloor(store) {
+    const inventory = await store.listAcceptedSchemaInventory();
+    for (const key of MANAGED_SOLUTION_PROFILE_KEYS) {
+        const definition = builtInDefinition(key);
+        if (definition.reference.kind !== 'managed') {
+            throw new Error(`managed definition resolver returned a non-managed profile for "${key}"`);
+        }
+        assertManagedRollbackReaders(key, definition.reference.release, inventory);
+    }
+    const canonical = [...inventory]
+        .map((identity) => JSON.stringify(identity))
+        .sort()
+        .join('\n');
+    return {
+        inventory: {
+            acceptedSchemaIdentities: inventory.length,
+            digest: `sha256:${createHash('sha256').update(canonical).digest('hex')}`,
+        },
+        readerTargets: MANAGED_SOLUTION_PROFILE_KEYS.length,
+    };
+}
+//# sourceMappingURL=reader-floor.js.map

package/node_modules/@noodle-borg/service/dist/business-information/source-credential-fence.js

@@ -0,0 +1,79 @@
+export class SourceCredentialError extends Error {
+    code = 'source_authorization_lost';
+    constructor() {
+        super('source_authorization_lost');
+    }
+}
+const fenced = new WeakMap();
+/** Every source consumer uses this same adapter; persisted portable bindings cannot silently fall back. */
+export function fenceSourceStore(store, authority) {
+    const prior = fenced.get(store);
+    if (prior?.authority === authority && prior !== undefined)
+        return store;
+    if (prior)
+        store = prior.raw;
+    const current = (binding, work) => (authority ? authority.withCurrent(binding, work) : work(undefined));
+    const guard = (binding, work) => current(binding, (identity) => {
+        if (identity?.generation !== binding.credentialIdentity?.generation ||
+            identity?.account !== binding.credentialIdentity?.account ||
+            identity?.configuration !== binding.credentialIdentity?.configuration)
+            throw new SourceCredentialError();
+        return work();
+    });
+    const captured = (binding, work) => current(binding, (identity) => {
+        if (!identity && binding.credentialIdentity)
+            throw new SourceCredentialError();
+        const { credentialIdentity: ignored, ...rest } = binding;
+        void ignored;
+        return work({ ...rest, ...(identity ? { credentialIdentity: identity } : {}) });
+    });
+    async function read(input, work) {
+        const binding = await store.getBinding(input);
+        return binding ? guard(binding, work) : work();
+    }
+    const result = {
+        createBinding: (input) => captured(input, (value) => store.createBinding(value)),
+        replaceBinding: async (input) => {
+            const previous = await store.getBinding(input);
+            if (previous?.credentialIdentity && !input.credentialIdentity)
+                input = { ...input, credentialIdentity: previous.credentialIdentity };
+            return captured(input, (value) => store.replaceBinding({
+                ...value,
+                expectedRevision: input.expectedRevision,
+                now: input.now,
+            }));
+        },
+        getBinding: (input) => store.getBinding(input),
+        setBindingState: (input) => store.setBindingState(input),
+        requestRefresh: (input) => read(input, () => store.requestRefresh(input)),
+        claimDue: async (input) => {
+            const lease = await store.claimDue(input);
+            if (!lease)
+                return undefined;
+            try {
+                return await guard(lease.binding, async () => lease);
+            }
+            catch (error) {
+                await store.failLease({
+                    lease,
+                    now: input.now,
+                    errorCode: 'source_authorization_lost',
+                    retryAt: new Date(input.now.getTime() + 30_000),
+                });
+                throw error;
+            }
+        },
+        commitPage: (input) => guard(input.lease.binding, () => store.commitPage(input)),
+        resetCheckpoint: (input) => store.resetCheckpoint(input),
+        failLease: (input) => store.failLease(input),
+        listExternalRecords: (input) => read(input, () => store.listExternalRecords(input)),
+        getExternalRecord: (input) => read(input, () => store.getExternalRecord(input)),
+        suppressExternalRecord: (input) => store.suppressExternalRecord(input),
+        listSuppressions: (input) => store.listSuppressions(input),
+        restoreSuppressions: (input) => store.restoreSuppressions(input),
+        purgeExpired: (input) => store.purgeExpired(input),
+    };
+    fenced.set(result, { raw: store, authority });
+    return result;
+}
+//# sourceMappingURL=source-credential-fence.js.map

package/node_modules/@noodle-borg/service/dist/business-information/source-custody-budget.js

@@ -0,0 +1,30 @@
+/** Engineering safeguards, independent of commercial plans and customer Activity retention. */
+export const SOURCE_ORG_CUSTODY_BYTES = 1024 ** 3;
+export const SOURCE_MAX_REPLICA_ROWS = 100_000;
+export const SOURCE_MAX_REFRESH_KEYS = 50_000;
+/** A conservative, validated upper bound for a row's non-payload representation. */
+export const SOURCE_METADATA_BYTES = 4096;
+export const SOURCE_REFRESH_REPLAY_MS = 30 * 86_400_000;
+export class SourceCapacityError extends Error {
+    code = 'source_capacity_exceeded';
+    constructor() {
+        super('Reference storage is full. Retained records remain available. Narrow the source or erase local records; refresh receipts recover capacity after their replay window.');
+        this.name = 'SourceCapacityError';
+    }
+}
+export function sourceDatasetCharge(retained, baseline, projected) {
+    return baseline === undefined
+        ? 2 * retained
+        : Math.max(retained, 2 * Math.max(baseline, projected));
+}
+export function sourceRowCost(kind, payloadBytes, live) {
+    return (SOURCE_METADATA_BYTES + payloadBytes + (kind === 'record' && live ? SOURCE_METADATA_BYTES : 0));
+}
+export function sourceJsonBytes(value) {
+    return Buffer.byteLength(JSON.stringify(value), 'utf8');
+}
+export function assertSourceMetadata(value) {
+    if (sourceJsonBytes(value) > SOURCE_METADATA_BYTES)
+        throw new Error('Source metadata exceeds its reserved representation');
+}
+//# sourceMappingURL=source-custody-budget.js.map

package/node_modules/@noodle-borg/service/dist/business-information/source-custody-memory.js

@@ -0,0 +1,122 @@
+import { assertSourceMetadata, SOURCE_MAX_REFRESH_KEYS, SOURCE_MAX_REPLICA_ROWS, SOURCE_METADATA_BYTES, SOURCE_ORG_CUSTODY_BYTES, SourceCapacityError, sourceDatasetCharge, sourceJsonBytes, sourceRowCost, } from './source-custody-budget.js';
+import { bindingKey } from './source-ingestion-memory-state.js';
+/** Development-only accounting; production maintains the same conservative counters in PostgreSQL. */
+export class SourceMemoryCapacity {
+    maximum;
+    #baselines = new Map();
+    constructor(maximum = SOURCE_ORG_CUSTODY_BYTES) {
+        this.maximum = maximum;
+    }
+    admit(before, after) {
+        const baselines = new Map(this.#baselines);
+        const previous = measure(before, this.#baselines);
+        const raw = measure(after, baselines);
+        for (const [key, { record }] of after.bindings) {
+            const old = before.bindings.get(key)?.record;
+            if (record.scanMode !== 'snapshot')
+                baselines.delete(key);
+            else if (old?.scanMode !== 'snapshot' || old.scanGeneration !== record.scanGeneration) {
+                baselines.set(key, raw.bindings.get(key)?.retained ?? 0);
+            }
+        }
+        for (const key of baselines.keys())
+            if (!after.bindings.has(key))
+                baselines.delete(key);
+        const next = measure(after, baselines);
+        for (const [org, bytes] of next.organizations) {
+            if (bytes > Math.max(this.maximum, previous.organizations.get(org) ?? 0))
+                throw new SourceCapacityError();
+        }
+        for (const [key, usage] of next.installations) {
+            const old = previous.installations.get(key);
+            if (usage.rows > Math.max(SOURCE_MAX_REPLICA_ROWS, old?.rows ?? 0) ||
+                usage.slots > Math.max(2 * SOURCE_MAX_REPLICA_ROWS, old?.slots ?? 0) ||
+                usage.refresh > Math.max(SOURCE_MAX_REFRESH_KEYS, old?.refresh ?? 0))
+                throw new SourceCapacityError();
+        }
+        this.#baselines = baselines;
+    }
+}
+function measure(state, baselines) {
+    const bindings = new Map();
+    const organizations = new Map();
+    const installations = new Map();
+    const installation = (key) => {
+        const scope = key.split('\0').slice(0, 4).join('\0');
+        let value = installations.get(scope);
+        if (value === undefined) {
+            value = { rows: 0, slots: 0, refresh: 0 };
+            installations.set(scope, value);
+        }
+        return value;
+    };
+    for (const [key, { record }] of state.bindings) {
+        const { scan, credentialIdentity, bindingReference, configurationReference, cursor, checkpoint, ...metadata } = record;
+        assertSourceMetadata(metadata);
+        const bytes = 2 * SOURCE_METADATA_BYTES +
+            sourceJsonBytes({
+                scan,
+                credentialIdentity,
+                bindingReference,
+                configurationReference,
+                cursor,
+                checkpoint,
+            });
+        bindings.set(key, { retained: bytes, projected: bytes });
+        installation(key);
+    }
+    for (const stored of state.records.values()) {
+        const record = stored.record;
+        const key = bindingKey({
+            scope: record.scope,
+            collectionKey: record.collectionKey,
+            id: record.source.bindingId,
+        });
+        const usage = required(bindings.get(key));
+        const { record: payload, source, ...metadata } = record;
+        assertSourceMetadata({
+            ...metadata,
+            source: { bindingId: source.bindingId, bindingGeneration: source.bindingGeneration },
+        });
+        const live = record.deletedAt === undefined;
+        const bytes = sourceRowCost('record', live ? sourceJsonBytes({ sourceId: source.id, version: source.version, record: payload }) : 0, live);
+        usage.retained += bytes;
+        usage.projected +=
+            live &&
+                state.bindings.get(key)?.record.scanMode === 'snapshot' &&
+                stored.lastSeenGeneration !== state.bindings.get(key)?.record.scanGeneration
+                ? SOURCE_METADATA_BYTES
+                : bytes;
+        const count = installation(key);
+        count.rows += 1;
+        count.slots += live ? 2 : 1;
+    }
+    for (const suppression of state.suppressions.values()) {
+        assertSourceMetadata(suppression);
+        const key = bindingKey(suppression);
+        const usage = required(bindings.get(key));
+        usage.retained += SOURCE_METADATA_BYTES;
+        usage.projected += SOURCE_METADATA_BYTES;
+        installation(key).slots += 1;
+    }
+    for (const [key, value] of bindings) {
+        const org = required(state.bindings.get(key)).record.scope.org;
+        organizations.set(org, (organizations.get(org) ?? SOURCE_METADATA_BYTES) +
+            sourceDatasetCharge(value.retained, baselines.get(key), value.projected));
+    }
+    for (const refresh of state.refresh.values()) {
+        assertSourceMetadata(refresh);
+        const org = refresh.bindingKey.split('\0')[0];
+        if (org === undefined)
+            throw new Error('Missing source receipt scope');
+        organizations.set(org, (organizations.get(org) ?? SOURCE_METADATA_BYTES) + SOURCE_METADATA_BYTES);
+        installation(refresh.bindingKey).refresh += 1;
+    }
+    return { bindings, organizations, installations };
+}
+function required(value) {
+    if (value === undefined)
+        throw new Error('Source custody scope is missing');
+    return value;
+}
+//# sourceMappingURL=source-custody-memory.js.map