@noodleseed/one 0.161.2 → 0.163.0

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

@@ -0,0 +1,439 @@
+import type { ArtifactVariableDeclaration, ManagedCollectionControls } from '@noodle-borg/compiler';
+import type { ManagedRecordQuery } from '@noodle-borg/wire-contracts';
+import type { BusinessNoticeStore } from './business-notice.js';
+import type { BusinessPrincipalProvider } from './principal-authority.js';
+export type JsonPrimitive = string | number | boolean | null;
+export type JsonValue = JsonPrimitive | JsonObject | readonly JsonValue[];
+export interface JsonObject {
+    readonly [key: string]: JsonValue;
+}
+export declare const MANAGED_RETENTION_DAYS: readonly [7, 30, 90];
+export type ManagedRetentionDays = (typeof MANAGED_RETENTION_DAYS)[number];
+export declare const BUSINESS_ROLES: readonly ["administrator", "manager", "operator", "viewer"];
+export type BusinessRole = (typeof BUSINESS_ROLES)[number];
+export type BusinessPermission = 'installation:administer' | 'grants:manage' | 'records:create' | 'records:read' | 'records:update' | 'records:assign' | 'records:status' | 'records:note' | 'records:delete' | 'records:export';
+export declare const MANAGED_REQUEST_STATUSES: readonly ["new", "in_progress", "resolved", "closed"];
+export type ManagedRequestStatus = (typeof MANAGED_REQUEST_STATUSES)[number];
+export declare const BUILT_IN_PROFILE_KEYS: readonly ["travel", "b2b_saas", "ecommerce", "restaurant"];
+export type BuiltInProfileKey = (typeof BUILT_IN_PROFILE_KEYS)[number];
+export interface NativeCollectionAuthority {
+    readonly authority: 'native';
+}
+export interface ExternalCollectionAuthority {
+    readonly authority: 'external';
+    readonly connectorAlias: string;
+    readonly connectorId: string;
+    readonly connectorVersion: string;
+    readonly scanOperation: string;
+    readonly scanSignatureHash: string;
+}
+export type CollectionAuthority = NativeCollectionAuthority | ExternalCollectionAuthority;
+export interface InstalledCollectionDefinition extends ManagedCollectionControls {
+    readonly key: string;
+    readonly title: string;
+    readonly singularTitle: string;
+    readonly description: string;
+    readonly schemaVersion: number;
+    readonly schemaDigest: string;
+    readonly recordSchema: JsonObject;
+    readonly summaryFields: readonly string[];
+    readonly authority: CollectionAuthority;
+    /** Historical release decoder only. New definitions use independently optional management controls. */
+    readonly behavior?: {
+        readonly kind: 'request';
+    };
+}
+export type SolutionDefinitionReference = {
+    readonly kind: 'managed';
+    readonly definitionId: 'travel' | 'ecommerce' | 'restaurant';
+    readonly release: number;
+    readonly digest: string;
+} | {
+    readonly kind: 'private';
+    readonly publisherOrg: string;
+    readonly app: string;
+    readonly env: string;
+    readonly deploymentId: string;
+    readonly version: string;
+    readonly digest: string;
+} | {
+    readonly kind: 'legacy';
+    readonly definitionId: 'b2b_saas';
+    readonly release: number;
+    readonly digest: string;
+};
+export interface SolutionDefinitionSnapshot {
+    readonly reference: SolutionDefinitionReference;
+    readonly title: string;
+    readonly description: string;
+    readonly collections: readonly InstalledCollectionDefinition[];
+    readonly variables?: readonly ArtifactVariableDeclaration[];
+}
+export interface InstallationScope {
+    readonly org: string;
+    readonly app: string;
+    readonly env: string;
+    readonly installationId: string;
+}
+export interface SolutionInstallation {
+    readonly scope: InstallationScope;
+    /** Opaque stable identifier for public channel resolution; never grants access by possession. */
+    readonly publicId: string;
+    /** Legacy storage key retained while old installations are served and backfilled. */
+    readonly profileKey: string;
+    readonly profileVersion: number;
+    readonly managedCollections: readonly string[];
+    readonly definition: SolutionDefinitionSnapshot;
+    readonly retentionDays: ManagedRetentionDays;
+    /** Public native-record intake exposure; authorized records remain operable while paused. */
+    readonly intakeActive: boolean;
+    /** Internal binding to the authoritative app incarnation; never a Portal configuration value. */
+    readonly applicationGeneration?: string;
+    readonly revision: number;
+    readonly createdAt: string;
+    readonly createdBySubject: string;
+    readonly updatedAt: string;
+    readonly updatedBySubject: string;
+}
+export interface BusinessGrant {
+    readonly scope: InstallationScope;
+    readonly subject: string;
+    readonly email?: string;
+    readonly role: BusinessRole;
+    readonly revision: number;
+    readonly createdAt: string;
+    readonly createdBySubject: string;
+    readonly updatedAt: string;
+    readonly updatedBySubject: string;
+    readonly revokedAt?: string;
+}
+export interface BusinessInvitation {
+    readonly scope: InstallationScope;
+    readonly invitationId: string;
+    readonly email: string;
+    readonly role: BusinessRole;
+    /** SHA-256 digest of the high-entropy bearer token; the raw token is never persisted. */
+    readonly tokenDigest: string;
+    readonly idempotencyDigest: string;
+    readonly createFingerprint: string;
+    readonly revision: number;
+    readonly createdAt: string;
+    readonly expiresAt: string;
+    readonly createdBySubject: string;
+    readonly acceptedAt?: string;
+    readonly acceptedBySubject?: string;
+    readonly revokedAt?: string;
+    readonly revokedBySubject?: string;
+}
+export interface ManagedRequestOrigin {
+    readonly kind: 'embedded' | 'mcp' | 'portal' | 'api' | 'import';
+    readonly reference?: string;
+}
+export interface ManagedRequestNote {
+    readonly id: string;
+    readonly text: string;
+    readonly createdAt: string;
+    readonly createdBySubject: string;
+}
+export interface ManagedRequestContent {
+    readonly payload: JsonObject;
+    readonly notes: readonly ManagedRequestNote[];
+}
+export interface ManagedRequestRecord {
+    readonly originalSchema?: {
+        readonly profileVersion: number;
+        readonly schemaVersion: number;
+        readonly schemaDigest: string;
+    };
+    readonly scope: InstallationScope;
+    readonly collectionKey: string;
+    readonly id: string;
+    readonly profileKey: string;
+    readonly profileVersion: number;
+    readonly schemaVersion: number;
+    readonly schemaDigest: string;
+    readonly status?: ManagedRequestStatus;
+    readonly assigneeSubject?: string;
+    readonly origin: ManagedRequestOrigin;
+    readonly revision: number;
+    readonly retentionExpiresAt: string;
+    readonly createdAt: string;
+    readonly createdBySubject: string;
+    readonly updatedAt: string;
+    readonly updatedBySubject: string;
+    readonly deletedAt?: string;
+    readonly deletionReason?: 'customer_request' | 'retention_expired';
+    readonly content?: ManagedRequestContent;
+}
+/** Payload-free identity of a schema that has accepted at least one durable business record. */
+export type AcceptedBusinessInformationSchema = Pick<ManagedRequestRecord, 'profileKey' | 'profileVersion' | 'collectionKey' | 'schemaVersion' | 'schemaDigest'>;
+export type ManagedRequestActivityKind = 'created' | 'updated' | 'assigned' | 'status_changed' | 'note_added' | 'schema_migrated' | 'deleted' | 'retention_expired';
+export interface RequestActivityPage {
+    readonly activities: readonly ManagedRequestActivity[];
+    readonly nextCursor?: string;
+}
+export interface ManagedRequestActivity {
+    readonly scope: InstallationScope;
+    readonly collectionKey: string;
+    readonly recordId: string;
+    readonly revision: number;
+    readonly kind: ManagedRequestActivityKind;
+    readonly status?: ManagedRequestStatus;
+    readonly assigneeSubject?: string;
+    readonly occurredAt: string;
+    readonly actorSubject: string;
+    readonly content?: ManagedRequestContent;
+}
+export interface PayloadCipherContext extends InstallationScope {
+    readonly collectionKey: string;
+    readonly recordId: string;
+    readonly revision: number;
+}
+/** An opaque authenticated-encryption envelope. Implementations own nonce/tag encoding in ciphertext. */
+export interface SealedPayload {
+    readonly version: 1;
+    readonly algorithm: string;
+    readonly keyId: string;
+    readonly ciphertext: string;
+}
+export interface PayloadCipher {
+    seal(plaintext: Uint8Array, context: PayloadCipherContext): Promise<SealedPayload>;
+    open(payload: SealedPayload, context: PayloadCipherContext): Promise<Uint8Array>;
+}
+export type InstallationCreateResult = {
+    readonly disposition: 'created' | 'replayed';
+    readonly installation: SolutionInstallation;
+} | {
+    readonly disposition: 'conflict';
+    readonly installation: SolutionInstallation;
+};
+export type GrantMutationResult = {
+    readonly ok: true;
+    readonly grant: BusinessGrant;
+} | {
+    readonly ok: false;
+    readonly reason: 'not_found' | 'conflict' | 'last_administrator';
+    readonly currentRevision: number;
+};
+export type InvitationCreateResult = {
+    readonly disposition: 'created' | 'replayed';
+    readonly invitation: BusinessInvitation;
+} | {
+    readonly disposition: 'conflict';
+    readonly invitation: BusinessInvitation;
+};
+export type InvitationMutationResult = {
+    readonly ok: true;
+    readonly invitation: BusinessInvitation;
+} | {
+    readonly ok: false;
+    readonly reason: 'not_found' | 'conflict' | 'already_used';
+    readonly currentRevision: number;
+};
+export type InvitationClaimResult = {
+    readonly ok: true;
+    readonly invitation: BusinessInvitation;
+    readonly grant: BusinessGrant;
+} | {
+    readonly ok: false;
+    readonly reason: 'not_found' | 'expired' | 'revoked' | 'already_used' | 'email_mismatch' | 'last_administrator';
+};
+export type RequestCreateResult = {
+    readonly disposition: 'created' | 'replayed';
+    readonly record: ManagedRequestRecord;
+} | {
+    readonly disposition: 'conflict';
+    readonly record: ManagedRequestRecord;
+} | {
+    readonly disposition: 'paused';
+};
+export type RequestCreateProbeResult = {
+    readonly disposition: 'missing';
+} | {
+    readonly disposition: 'replayed' | 'conflict';
+    readonly record: ManagedRequestRecord;
+};
+export type InstallationMutationResult = {
+    readonly ok: true;
+    readonly installation: SolutionInstallation;
+} | {
+    readonly ok: false;
+    readonly reason: 'not_found' | 'conflict' | 'invalid_state' | 'application_unavailable';
+    readonly currentRevision: number;
+};
+export type RequestMutationResult = {
+    readonly ok: true;
+    readonly record: ManagedRequestRecord;
+} | {
+    readonly ok: false;
+    readonly reason: 'not_found' | 'conflict' | 'invalid_transition' | 'invalid_assignee';
+    readonly currentRevision: number;
+};
+export type ManagedRequestOperation = {
+    readonly kind: 'update';
+    readonly payload: unknown;
+    readonly unset?: readonly string[];
+} | {
+    readonly kind: 'assign';
+    readonly assigneeSubject: string | undefined;
+} | {
+    readonly kind: 'set_status';
+    readonly status: ManagedRequestStatus;
+} | {
+    readonly kind: 'add_note';
+    readonly note: string;
+};
+export interface RequestPage {
+    readonly records: readonly ManagedRequestRecord[];
+    readonly nextCursor?: string;
+}
+export interface RequestExportPage extends RequestPage {
+    readonly snapshotAt: string;
+}
+export interface SolutionInstallationStore {
+    bindApplication(scope: InstallationScope, generation: string): Promise<boolean>;
+    pauseApplication(org: string, app: string, at: string, retired?: boolean): Promise<void>;
+    createInstallation(input: {
+        readonly scope: InstallationScope;
+        readonly profileKey?: BuiltInProfileKey;
+        readonly definition?: SolutionDefinitionSnapshot;
+        readonly managedCollections: readonly string[];
+        readonly retentionDays?: ManagedRetentionDays;
+        readonly actorSubject: string;
+        readonly actorEmail?: string;
+    }): Promise<InstallationCreateResult>;
+    getInstallation(scope: InstallationScope): Promise<SolutionInstallation | undefined>;
+    getInstallationById(org: string, installationId: string): Promise<SolutionInstallation | undefined>;
+    resolveInstallationByPublicId(publicId: string): Promise<SolutionInstallation | undefined>;
+    listInstallations(org: string): Promise<readonly SolutionInstallation[]>;
+    listInstallationsForSubject(subject: string): Promise<readonly {
+        readonly installation: SolutionInstallation;
+        readonly grant: BusinessGrant;
+    }[]>;
+    setIntakeState(input: {
+        readonly scope: InstallationScope;
+        readonly expectedRevision: number;
+        readonly active: boolean;
+        readonly actorSubject: string;
+    }): Promise<InstallationMutationResult>;
+}
+export interface BusinessGrantStore {
+    getGrant(scope: InstallationScope, subject: string): Promise<BusinessGrant | undefined>;
+    listGrants(scope: InstallationScope): Promise<readonly BusinessGrant[]>;
+    setGrant(input: {
+        readonly scope: InstallationScope;
+        readonly subject: string;
+        readonly email: string;
+        readonly role: BusinessRole;
+        readonly expectedRevision: number;
+        readonly actorSubject: string;
+    }): Promise<GrantMutationResult>;
+    revokeGrant(input: {
+        readonly scope: InstallationScope;
+        readonly subject: string;
+        readonly expectedRevision: number;
+        readonly actorSubject: string;
+    }): Promise<GrantMutationResult>;
+    createInvitation(input: {
+        readonly scope: InstallationScope;
+        readonly invitationId: string;
+        readonly email: string;
+        readonly role: BusinessRole;
+        readonly tokenDigest: string;
+        readonly idempotencyKey: string;
+        readonly expiresAt: Date;
+        readonly actorSubject: string;
+    }): Promise<InvitationCreateResult>;
+    listInvitations(scope: InstallationScope): Promise<readonly BusinessInvitation[]>;
+    revokeInvitation(input: {
+        readonly scope: InstallationScope;
+        readonly invitationId: string;
+        readonly expectedRevision: number;
+        readonly actorSubject: string;
+    }): Promise<InvitationMutationResult>;
+    claimInvitation(input: {
+        readonly tokenDigest: string;
+        readonly subject: string;
+        readonly email: string;
+    }): Promise<InvitationClaimResult>;
+}
+export interface ManagedRequestStore {
+    /** Explicit authorized release migration; no read-time rewrite or broader record grants. */
+    migrateLegacyRequest(input: {
+        readonly scope: InstallationScope;
+        readonly collectionKey: string;
+        readonly id: string;
+        readonly expectedRevision: number;
+        readonly actorSubject: string;
+    }): Promise<RequestMutationResult>;
+    /** Authoritative, de-duplicated inventory used to prove release reader compatibility. */
+    listAcceptedSchemaInventory(): Promise<readonly AcceptedBusinessInformationSchema[]>;
+    /** Read completed idempotency evidence without creating a record or spending admission. */
+    probeRequest(input: {
+        readonly publicInput?: true;
+        readonly scope: InstallationScope;
+        readonly collectionKey: string;
+        readonly idempotencyKey: string;
+        readonly payload: unknown;
+        readonly origin: ManagedRequestOrigin;
+        readonly actorSubject: string;
+    }): Promise<RequestCreateProbeResult>;
+    createRequest(input: {
+        readonly publicInput?: true;
+        readonly scope: InstallationScope;
+        readonly collectionKey: string;
+        readonly idempotencyKey: string;
+        readonly payload: unknown;
+        readonly origin: ManagedRequestOrigin;
+        readonly actorSubject: string;
+    }): Promise<RequestCreateResult>;
+    getRequest(scope: InstallationScope, collectionKey: string, id: string, options?: {
+        readonly includeDeleted?: boolean;
+    }): Promise<ManagedRequestRecord | undefined>;
+    listRequests(input: ManagedRecordQuery & {
+        readonly scope: InstallationScope;
+        readonly collectionKey: string;
+        readonly status?: ManagedRequestStatus;
+        readonly assigneeSubject?: string;
+        readonly cursor?: string;
+        readonly limit?: number;
+        readonly includeDeleted?: boolean;
+    }): Promise<RequestPage>;
+    mutateRequest(input: {
+        readonly scope: InstallationScope;
+        readonly collectionKey: string;
+        readonly id: string;
+        readonly expectedRevision: number;
+        readonly actorSubject: string;
+        readonly operation: ManagedRequestOperation;
+    }): Promise<RequestMutationResult>;
+    deleteRequest(input: {
+        readonly scope: InstallationScope;
+        readonly collectionKey: string;
+        readonly id: string;
+        readonly expectedRevision: number;
+        readonly actorSubject: string;
+        readonly reason: 'customer_request';
+    }): Promise<RequestMutationResult>;
+    listActivity(scope: InstallationScope, collectionKey: string, id: string, paging?: {
+        readonly cursor?: string;
+        readonly limit?: number;
+    }): Promise<RequestActivityPage>;
+    exportRequests(input: {
+        readonly scope: InstallationScope;
+        readonly collectionKey: string;
+        readonly cursor?: string;
+        readonly limit?: number;
+        readonly includeDeleted?: boolean;
+    }): Promise<RequestExportPage>;
+    /** Erases expired content and retains payload-free tombstones. */
+    purgeExpired(input: {
+        readonly scope?: InstallationScope;
+        readonly limit?: number;
+    }): Promise<number>;
+}
+export interface BusinessInformationStore extends SolutionInstallationStore, BusinessNoticeStore, BusinessGrantStore, ManagedRequestStore {
+    configurePrincipalAuthority(provider: BusinessPrincipalProvider | undefined): void;
+    listEligibleAssignees(scope: InstallationScope): Promise<readonly BusinessGrant[]>;
+}
+//# sourceMappingURL=contracts.d.ts.map

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

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

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

@@ -0,0 +1,94 @@
+import { sha256Canonical } from '@noodle-borg/app-package';
+import { projectManagedCollectionControls } from '@noodle-borg/compiler';
+/**
+ * Validate and freeze an active deployment as an immutable private solution definition.
+ * Authorization and active-deployment lookup happen before this pure boundary.
+ */
+export function privateDefinitionFromDeployment(selector, deployment) {
+    if (deployment.deploymentId !== selector.deploymentId ||
+        deployment.org !== selector.publisherOrg ||
+        deployment.app !== selector.app ||
+        deployment.environment !== selector.environment) {
+        throw new Error('private definition deployment does not match the requested immutable reference');
+    }
+    if (deployment.artifact.resolution !== 'resolved') {
+        throw new Error('private definition requires a fully resolved runtime artifact');
+    }
+    const authored = deployment.artifact.server.managedCollections ?? [];
+    const collections = authored.map(collectionFromArtifact);
+    const digest = sha256Canonical({
+        deploymentId: deployment.deploymentId,
+        server: {
+            name: deployment.artifact.server.name,
+            version: deployment.artifact.server.version,
+            title: deployment.artifact.server.title,
+            managedCollections: authored,
+            ...(deployment.artifact.server.variables === undefined
+                ? {}
+                : { variables: deployment.artifact.server.variables }),
+        },
+    });
+    return {
+        reference: {
+            kind: 'private',
+            publisherOrg: deployment.org,
+            app: deployment.app,
+            env: deployment.environment,
+            deploymentId: deployment.deploymentId,
+            version: deployment.artifact.server.version,
+            digest,
+        },
+        title: deployment.artifact.server.title,
+        description: deployment.artifact.server.instructions ??
+            `Business operations for ${deployment.artifact.server.title}.`,
+        collections,
+        ...(deployment.artifact.server.variables === undefined
+            ? {}
+            : { variables: structuredClone(deployment.artifact.server.variables) }),
+    };
+}
+function collectionFromArtifact(collection) {
+    const source = collection.source;
+    const authority = source.authority === 'native' ? { authority: 'native' } : externalAuthority(source);
+    return {
+        key: collection.name,
+        title: collection.title,
+        singularTitle: singularize(collection.title),
+        description: collection.description,
+        schemaVersion: collection.schemaVersion,
+        schemaDigest: collection.schemaDigest.replace(/^sha256:/, ''),
+        recordSchema: structuredClone(collection.recordSchema),
+        ...projectManagedCollectionControls(collection),
+        summaryFields: collection.summaryFields ?? summaryFields(collection.recordSchema),
+        authority,
+        ...(collection.behavior === undefined ? {} : { behavior: collection.behavior }),
+    };
+}
+function externalAuthority(source) {
+    if (!source.scan.resolved) {
+        throw new Error('external collection source operations must be fully resolved');
+    }
+    return {
+        authority: 'external',
+        connectorAlias: source.connectorAlias,
+        connectorId: source.connectorId,
+        connectorVersion: source.connectorVersion,
+        scanOperation: source.scan.operation,
+        scanSignatureHash: source.scan.signatureHash,
+    };
+}
+function summaryFields(schema) {
+    const required = Array.isArray(schema.required)
+        ? schema.required.filter((field) => typeof field === 'string')
+        : [];
+    const properties = schema.properties !== null &&
+        typeof schema.properties === 'object' &&
+        !Array.isArray(schema.properties)
+        ? Object.keys(schema.properties)
+        : [];
+    return [...new Set([...required, ...properties])].slice(0, 6);
+}
+function singularize(title) {
+    return title.endsWith('s') && title.length > 1 ? title.slice(0, -1) : title;
+}
+//# sourceMappingURL=definition-resolver.js.map

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

@@ -0,0 +1,136 @@
+import { BusinessNoticeError, validatedNotice, } from './business-notice.js';
+import { effectiveInstallation, validateExpectedRevision } from './model.js';
+import { scopeKey } from './pagination.js';
+import { validateScalar, validateScope } from './validation.js';
+/** Process-local lifecycle serialization shares the native intake lock. */
+export class InMemoryInstallationLifecycle {
+    #installations;
+    #withLock;
+    #now;
+    #managedDefinition;
+    #application;
+    #notices = new Map();
+    #getGrant;
+    constructor(input) {
+        this.#installations = input.installations;
+        this.#getGrant = input.getGrant;
+        this.#withLock = input.withLock;
+        this.#now = input.now;
+        this.#managedDefinition = input.managedDefinition;
+    }
+    getInstallation(scope) {
+        const found = this.#installations.get(scopeKey(validateScope(scope)));
+        return Promise.resolve(found === undefined ? undefined : effectiveInstallation(found, this.#managedDefinition));
+    }
+    listInstallations(org) {
+        const normalized = validateScalar('organization', org, 63);
+        return Promise.resolve([...this.#installations.values()]
+            .filter((installation) => installation.scope.org === normalized)
+            .sort((left, right) => left.createdAt.localeCompare(right.createdAt))
+            .map((installation) => effectiveInstallation(installation, this.#managedDefinition)));
+    }
+    getBusinessNotice(scope) {
+        return Promise.resolve(structuredClone(this.#notices.get(scopeKey(validateScope(scope)))));
+    }
+    async setBusinessNotice(input) {
+        const scope = validateScope(input.scope);
+        const notice = validatedNotice(input);
+        return this.#withLock(`grants:${scopeKey(scope)}`, async () => {
+            const grant = this.#getGrant(scope, input.actorSubject);
+            if (grant?.role !== 'administrator' || grant.revokedAt)
+                throw new BusinessNoticeError('business_notice_forbidden');
+            const key = scopeKey(scope);
+            const current = this.#notices.get(key);
+            if ((current?.revision ?? 0) !== input.expectedRevision)
+                throw new BusinessNoticeError('business_notice_conflict');
+            const record = {
+                notice,
+                revision: input.expectedRevision + 1,
+                updatedAt: this.#now().toISOString(),
+                updatedBySubject: input.actorSubject,
+            };
+            this.#notices.set(key, record);
+            return structuredClone(record);
+        });
+    }
+    configureApplicationLifecycle(resolve) {
+        this.#application = resolve;
+    }
+    async applicationAllows(installation) {
+        if (!this.#application)
+            return true;
+        const app = await this.#application(installation.scope);
+        return app?.active === true && app.generation === installation.applicationGeneration;
+    }
+    async bindApplication(scope, generation) {
+        if (!Number.isFinite(Date.parse(generation)))
+            return false;
+        return this.#withLock(`intake:${scopeKey(scope)}`, async () => {
+            const current = this.#installations.get(scopeKey(scope));
+            if (!current)
+                return false;
+            const app = await this.#application?.(scope);
+            if (this.#application && (!app?.active || app.generation !== generation))
+                return false;
+            if (current.applicationGeneration === generation)
+                return true;
+            if (current.applicationGeneration !== 'pending' &&
+                (current.applicationGeneration !== undefined ||
+                    Date.parse(generation) > Date.parse(current.createdAt)))
+                return false;
+            this.#installations.set(scopeKey(scope), { ...current, applicationGeneration: generation });
+            return true;
+        });
+    }
+    async pauseApplication(org, app, at, retired = false) {
+        for (const installation of this.#installations.values()) {
+            if (installation.scope.org !== org || installation.scope.app !== app)
+                continue;
+            await this.#withLock(`intake:${scopeKey(installation.scope)}`, async () => {
+                const current = this.#installations.get(scopeKey(installation.scope));
+                if (current &&
+                    (current.intakeActive || (retired && current.applicationGeneration !== 'retired')))
+                    this.#installations.set(scopeKey(current.scope), {
+                        ...current,
+                        intakeActive: false,
+                        revision: current.revision + 1,
+                        updatedAt: at,
+                        updatedBySubject: retired ? 'noodle:application-purge' : 'noodle:application-archive',
+                        ...(retired ? { applicationGeneration: 'retired' } : {}),
+                    });
+            });
+        }
+    }
+    async setIntakeState(input) {
+        const scope = validateScope(input.scope);
+        validateExpectedRevision(input.expectedRevision);
+        const actor = validateScalar('actor subject', input.actorSubject, 256);
+        return this.#withLock(`intake:${scopeKey(scope)}`, async () => {
+            const key = scopeKey(scope);
+            const current = this.#installations.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 (input.active && !(await this.applicationAllows(current)))
+                return { ok: false, reason: 'application_unavailable', currentRevision: current.revision };
+            if (current.intakeActive === input.active) {
+                return { ok: false, reason: 'invalid_state', currentRevision: current.revision };
+            }
+            const installation = {
+                ...current,
+                intakeActive: input.active,
+                revision: current.revision + 1,
+                updatedAt: this.#now().toISOString(),
+                updatedBySubject: actor,
+            };
+            this.#installations.set(key, installation);
+            return {
+                ok: true,
+                installation: effectiveInstallation(installation, this.#managedDefinition),
+            };
+        });
+    }
+}
+//# sourceMappingURL=in-memory-installation-lifecycle.js.map