@noodleseed/one 0.162.0 → 0.163.0

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

@@ -1,6 +1,9 @@
 import { createHash } from 'node:crypto';
-import { builtInCollection, builtInProfile, validateProfilePayload } from './profiles.js';
-import { validateEmail, validateManagedPayload, validateRetentionDays, validateRevision, validateScalar, validateScope, } from './validation.js';
+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',
@@ -46,16 +49,30 @@ export function businessGrantAllows(grant, permission) {
 }
 export function normalizeInstallationInput(input) {
     const scope = { ...validateScope(input.scope) };
-    const profile = builtInProfile(input.profileKey);
+    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();
-    if (managedCollections.length === 0)
-        throw new Error('at least one managed collection must be enabled');
-    for (const collectionKey of managedCollections)
-        builtInCollection(profile.key, collectionKey);
+    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: profile.key,
-        profileVersion: profile.version,
+        profileKey,
+        profileVersion,
+        definition: structuredClone(definition),
         managedCollections,
         retentionDays: validateRetentionDays(input.retentionDays),
         actorSubject: validateScalar('actor subject', input.actorSubject, 256),
@@ -63,16 +80,32 @@ export function normalizeInstallationInput(input) {
     };
 }
 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,
-        profileVersion: input.profileVersion,
+        ...definitionIntent,
         managedCollections: input.managedCollections,
         retentionDays: input.retentionDays,
         actorSubject: input.actorSubject,
-        actorEmail: input.actorEmail,
+        ...(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);
 }
@@ -84,23 +117,29 @@ export function validateCollectionEnabled(installation, collectionKey) {
     if (!installation.managedCollections.includes(normalized)) {
         throw new Error(`managed collection "${normalized}" is not enabled for this installation`);
     }
-    return builtInCollection(installation.profileKey, normalized);
+    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 profile = validateCollectionEnabled(input.installation, input.collectionKey);
-    const payload = validateProfilePayload(input.installation.profileKey, input.collectionKey, input.payload);
+    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: profile.key,
+        collectionKey: collection.key,
         id,
         profileKey: input.installation.profileKey,
         profileVersion: input.installation.profileVersion,
-        schemaVersion: profile.schemaVersion,
-        schemaDigest: profile.schemaDigest,
-        status: 'new',
+        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(),
@@ -111,14 +150,16 @@ export function initialRecord(input) {
         content: { payload, notes: [] },
     };
 }
-export function applyRequestOperation(current, operation, actorSubject, now, noteId) {
+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 = validateProfilePayload(current.profileKey, current.collectionKey, operation.payload);
+        const payload = validateCollectionPayload(collection, patchedPayload(collection, current.content.payload, operation.payload, operation.unset));
         return {
             record: cloneRecord({
                 ...current,
@@ -131,6 +172,8 @@ export function applyRequestOperation(current, operation, actorSubject, now, not
         };
     }
     if (operation.kind === 'assign') {
+        if (!collectionControlEnabled(collection, 'assignment'))
+            return undefined;
         const assignee = operation.assigneeSubject === undefined
             ? undefined
             : validateScalar('assignee subject', operation.assigneeSubject, 256);
@@ -148,6 +191,8 @@ export function applyRequestOperation(current, operation, actorSubject, now, not
         };
     }
     if (operation.kind === 'set_status') {
+        if (collection.behavior?.kind !== 'request' || current.status === undefined)
+            return undefined;
         if (!validStatusTransition(current.status, operation.status))
             return undefined;
         return {
@@ -161,9 +206,11 @@ export function applyRequestOperation(current, operation, actorSubject, now, not
             activityKind: 'status_changed',
         };
     }
+    if (!collectionControlEnabled(collection, 'notes'))
+        return undefined;
     const note = validateNote(operation.note);
     if (current.content.notes.length >= 50)
-        throw new Error('managed request cannot exceed 50 notes');
+        throw new PayloadValidationError('array_too_large', 'A record cannot have more than 50 notes.');
     return {
         record: cloneRecord({
             ...current,
@@ -186,6 +233,12 @@ export function applyRequestOperation(current, operation, actorSubject, now, not
         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();
@@ -208,7 +261,7 @@ export function activityFromRecord(record, kind) {
         recordId: record.id,
         revision: record.revision,
         kind,
-        status: record.status,
+        ...(record.status === undefined ? {} : { status: record.status }),
         ...(record.assigneeSubject === undefined ? {} : { assigneeSubject: record.assigneeSubject }),
         occurredAt: record.updatedAt,
         actorSubject: record.updatedBySubject,
@@ -218,6 +271,9 @@ export function activityFromRecord(record, kind) {
 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) }),
@@ -234,8 +290,17 @@ export function cloneInstallation(installation) {
         ...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 } };
 }
@@ -261,7 +326,9 @@ function normalizeOrigin(origin) {
     };
 }
 function validateNote(note) {
-    const normalized = validateScalar('note', note, 4096);
+    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;
 }
@@ -274,6 +341,40 @@ function validStatusTransition(from, to) {
         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');
 }

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

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

@@ -1,3 +1,4 @@
+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}`;
@@ -47,4 +48,31 @@ function isCursor(value) {
 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

@@ -1,6 +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