@noodleseed/one 0.164.0 → 0.166.0

package/node_modules/@noodle-borg/service/dist/registry-deploy-transaction.js

@@ -1,5 +1,7 @@
 import { normalizeServerVersion } from '@noodle-borg/module';
+import { deploymentRecordVersionError } from './deployment-record-version.js';
 import { deployAccessRequiresActor, deployerRequiredError, deploymentOwnerSubject, emptyMembershipSourcesError, membershipSourcesRequireOrgMembersError, missingCapabilityErrors, serverAuthRequiredError, } from './registry-helpers.js';
+import { activeRecord, activeRecordVersion } from './registry-state.js';
 import { idempotentDeploymentId, mintDeploymentId } from './registry-targets.js';
 /** Serialize candidate validation/activation with hierarchical configuration writers. */
 export async function withDeploymentConfiguration(config, org, work) {
@@ -19,6 +21,15 @@ export async function withDeploymentConfiguration(config, org, work) {
         throw error;
     }
 }
+/** Validate the exact destination scope before compilation or publication side effects. */
+export async function deploymentWriteVersionError(state, tenant, serverVersion) {
+    const active = serverVersion === undefined
+        ? await activeRecord(state, tenant)
+        : await activeRecordVersion(state, tenant, serverVersion);
+    return active !== undefined && active.serverVersion === serverVersion
+        ? deploymentRecordVersionError(active)
+        : undefined;
+}
 export async function preflightRegistryDeploy(input) {
     const { actor, accessMode, orgMembershipSources } = input.options;
     if (input.options.serverVersion !== undefined) {
@@ -67,6 +78,10 @@ export async function resolveDeployAttempt(input) {
     const existing = (await input.store?.get(deploymentId)) ?? input.records.get(deploymentId);
     if (existing === undefined)
         return { deploymentId };
+    const versionError = deploymentRecordVersionError(existing);
+    if (versionError !== undefined) {
+        return { deploymentId, replay: { ok: false, errors: [versionError] } };
+    }
     if (!sameIdempotentDeploy(existing, input.tenant, input.manifest, input.options)) {
         return {
             deploymentId,

package/node_modules/@noodle-borg/service/dist/registry-rollback.js

@@ -75,10 +75,12 @@ export async function rollbackDeployment(state, ref, deploymentId, compilePersis
     const activation = state.store
         ? await state.store.activateDeployment(ref, deploymentId, {
             expectedAccessMode: target.accessMode,
+            expectedSchemaVersion: target.schemaVersion,
             ...(compiledAuth !== undefined ? { serverAuth: compiledAuth } : {}),
         })
         : activateInMemory(state.records, ref, deploymentId, {
             expectedAccessMode: target.accessMode,
+            expectedSchemaVersion: target.schemaVersion,
             ...(compiledAuth !== undefined ? { serverAuth: compiledAuth } : {}),
         });
     if (activation === undefined) {

package/node_modules/@noodle-borg/service/dist/registry-state.d.ts

@@ -36,6 +36,7 @@ export declare function persistDeployRecord(view: RegistryStateView, record: Dep
 /** No-store activation fallback (moved verbatim from `ServerRegistry.#activateInMemory`). */
 export declare function activateInMemory(records: Map<string, DeployRecord>, ref: TenantRef, deploymentId: string, precondition?: {
     readonly expectedAccessMode: DeployRecord['accessMode'];
+    readonly expectedSchemaVersion?: number;
     readonly serverAuth?: DeployRecord['serverAuth'];
 }): {
     readonly active: DeployRecord;

package/node_modules/@noodle-borg/service/dist/registry-state.js

@@ -5,8 +5,9 @@
  * durable store first, then reconcile the in-process caches so no instance keeps serving stale state.
  */
 import { normalizeServerVersion } from '@noodle-borg/module';
-import { assertCustomerAuthRestorePrecondition, assertUniqueActiveCustomerAuthAudienceBindings, CustomerAuthAudienceProjectionError, hasExactCustomerAuthProjection, } from './customer-auth-audience-binding.js';
+import { assertCustomerAuthRestorePrecondition, assertUniqueActiveCustomerAuthAudienceBindings, CustomerAuthAudienceProjectionError, hasExactCustomerAuthProjection, requiresCustomerAuthProjection, } from './customer-auth-audience-binding.js';
 import { assertDeploymentActivationUnlocked, assertDeploymentAppendUnlocked, } from './deployment-lock.js';
+import { assertDeploymentAppendVersion } from './deployment-record-version.js';
 import { defaultActiveRecord } from './deployment-versioning.js';
 import { recordMatchesTenant, tenantDeploymentKey, tenantKey } from './registry-targets.js';
 import { appArchivedAt, deploymentSummary, paginateAppSummaries, planAppArchive, planAppRestore, planArchivedAppSweep, resolveProductionEnvironment, summarizeApps, summarizeEnvs, withoutArchiveStamp, } from './store/records.js';
@@ -34,6 +35,7 @@ export async function persistDeployRecord(view, record, tenant, activatesNow) {
         return persisted;
     }
     else {
+        assertDeploymentAppendVersion([...view.records.values()], record);
         if (!assertDeploymentAppendUnlocked([...view.records.values()], record)) {
             return view.records.get(record.deploymentId);
         }
@@ -66,18 +68,23 @@ export function activateInMemory(records, ref, deploymentId, precondition) {
     if (target === undefined || !recordMatchesTenant(target, ref))
         return undefined;
     assertDeploymentActivationUnlocked([...records.values()], target);
-    if (precondition !== undefined && target.accessMode !== precondition.expectedAccessMode) {
+    if (target.schemaVersion !== (precondition?.expectedSchemaVersion ?? 1) ||
+        (precondition !== undefined && target.accessMode !== precondition.expectedAccessMode)) {
         return undefined;
     }
     const previousActive = [...records.values()]
         .filter((record) => record.active && recordMatchesTenant(record, ref))
         .filter((record) => record.serverVersion === target.serverVersion)
         .sort((a, b) => b.deploymentVersion - a.deploymentVersion)[0];
+    if (precondition === undefined && previousActive !== undefined) {
+        assertDeploymentAppendVersion([previousActive], { ...target, active: true });
+    }
     const alreadyActive = previousActive?.deploymentId === deploymentId;
     const activated = {
         ...target,
         active: true,
-        ...(target.accessMode === 'customers' && precondition?.serverAuth !== undefined
+        ...(requiresCustomerAuthProjection(target, precondition?.serverAuth) &&
+            precondition?.serverAuth !== undefined
             ? { serverAuth: precondition.serverAuth }
             : {}),
     };
@@ -207,7 +214,7 @@ export async function registryRestoreApp(state, org, app, compileRecord) {
         return undefined;
     const projections = [];
     for (const record of plan.clear) {
-        if (!record.active || record.accessMode !== 'customers')
+        if (!record.active || !requiresCustomerAuthProjection(record))
             continue;
         const built = await compileRecord(record);
         const compiledAuth = built.ok ? built.served.artifact.server.auth : undefined;
@@ -243,7 +250,7 @@ export async function registryCustomerAuthRestoreProjections(state, deploymentId
         : state.store.get(deploymentId)));
     const projections = [];
     for (const record of records) {
-        if (record === undefined || !record.active || record.accessMode !== 'customers')
+        if (record === undefined || !record.active || !requiresCustomerAuthProjection(record))
             continue;
         const built = await compileRecord(record);
         const compiledAuth = built.ok ? built.served.artifact.server.auth : undefined;

package/node_modules/@noodle-borg/service/dist/registry-status.js

@@ -1,4 +1,5 @@
 import { tenantMcpUrl } from '@noodle-borg/module';
+import { deploymentAuthenticationFor } from './deployment-authentication.js';
 import { deploymentOwnerSubject, missingSecretNames } from './registry-helpers.js';
 /** Project one compiled deployment into the control-plane status contract. */
 export function deploymentStatusFor(ref, record, built, baseUrl, endpointOptions) {
@@ -8,6 +9,7 @@ export function deploymentStatusFor(ref, record, built, baseUrl, endpointOptions
         built.served.artifact.server.auth === undefined;
     const unhealthy = missingCustomerAuth || (!built.ok && missingSecrets.length === 0);
     const ownerSubject = deploymentOwnerSubject(record);
+    const authentication = deploymentAuthenticationFor(record);
     return {
         target: ref,
         deployment: {
@@ -20,6 +22,7 @@ export function deploymentStatusFor(ref, record, built, baseUrl, endpointOptions
             ...(record.createdByEmail !== undefined ? { createdByEmail: record.createdByEmail } : {}),
             ...(ownerSubject !== undefined ? { ownerSubject } : {}),
             accessMode: record.accessMode ?? 'owner-only',
+            ...(authentication !== undefined ? { authentication } : {}),
             ...(record.deploymentLock !== undefined
                 ? {
                     deploymentLock: {

package/node_modules/@noodle-borg/service/dist/registry-targets.js

@@ -2,6 +2,7 @@ import { createHash, randomUUID } from 'node:crypto';
 import { RECORD_CONNECTOR_ID } from '@noodle-borg/compiler';
 import { parseAppPackageSnapshot } from './app-package-snapshot.js';
 import { hasExactCustomerAuthProjection } from './customer-auth-audience-binding.js';
+import { deploymentRecordVersionError } from './deployment-record-version.js';
 import { deploymentOwnerSubject } from './registry-helpers.js';
 import { validateTenantRef } from './store.js';
 /** Replace only the platform record port; unrelated compiled runtime ports retain their authority. */
@@ -34,6 +35,9 @@ export function rebindNativeRecords(target, record, factory) {
  * front-door checks. Legacy alpha records without an identity access mode are not served.
  */
 export function servedTargetFor(record, served, customerVerifierFactory) {
+    const versionError = deploymentRecordVersionError(record);
+    if (versionError !== undefined)
+        throw new Error(versionError.code);
     const accessMode = record.accessMode;
     if (accessMode === undefined) {
         throw new Error(`deployment ${record.deploymentId} has unsupported legacy access mode`);
@@ -102,6 +106,10 @@ function bindAppPackageSnapshot(served, value) {
 export async function targetForPersistedRecord(record, state) {
     const cached = state.servers.get(record.deploymentId);
     state.records.set(record.deploymentId, record);
+    if (deploymentRecordVersionError(record) !== undefined) {
+        state.servers.delete(record.deploymentId);
+        return undefined;
+    }
     if (cached === undefined)
         return state.load?.();
     if (!hasExactCustomerAuthProjection(record, cached.served.artifact.server.auth)) {

package/node_modules/@noodle-borg/service/dist/registry-types.d.ts

@@ -73,7 +73,7 @@ export type RunDeployResult = DeployResult | {
     readonly deploymentVersion: number;
     readonly serverVersion?: string;
 };
-export type AccessUpdateFailureCode = 'no_active_deployment' | 'server_auth_required' | 'customer_auth_audience_conflict' | 'public_user_context_conflict' | 'owner_identity_required' | 'access_update_conflict';
+export type AccessUpdateFailureCode = 'unsupported_deployment_record_version' | 'no_active_deployment' | 'server_auth_required' | 'customer_auth_audience_conflict' | 'public_user_context_conflict' | 'owner_identity_required' | 'access_update_conflict';
 export type AccessUpdateResult = {
     readonly ok: true;
     readonly changed: boolean;

package/node_modules/@noodle-borg/service/dist/registry.js

@@ -1,19 +1,19 @@
 import { KnowledgePublicationError, withKnowledgePublication, } from '@noodle-borg/knowledge-operations/portable';
 import { DeploymentActivationError, normalizeServerVersion, } from '@noodle-borg/module';
-import { normalizePersistedConnectorsForCompile } from './connector-normalize.js';
 import { CustomerAuthAudienceConflictError, customerAuthAudienceConflictFailure, hasActiveCustomerAuthAudienceConflict, } from './customer-auth-audience-binding.js';
 import { DeploymentLockedError, deploymentLockedConflict, deploymentLockedPreflight, } from './deployment-lock.js';
+import { UnsupportedDeploymentRecordVersionError, unsupportedDeploymentRecordFailure, } from './deployment-record-version.js';
 import { defaultActiveRecord } from './deployment-versioning.js';
 import { updateRegistryAccess } from './registry-access.js';
-import { compileRegistryTarget } from './registry-compile.js';
-import { preflightRegistryDeploy, resolveDeployAttempt, withDeploymentConfiguration, } from './registry-deploy-transaction.js';
-import { deploymentOwnerSubject, missingCapabilityErrors, } from './registry-helpers.js';
+import { compilePersistedRegistryRecord, compileRegistryTarget, loadPersistedRegistryTarget, } from './registry-compile.js';
+import { deploymentWriteVersionError, preflightRegistryDeploy, resolveDeployAttempt, withDeploymentConfiguration, } from './registry-deploy-transaction.js';
+import { deploymentOwnerSubject } from './registry-helpers.js';
 import { registryDeploymentPackage, renderDeploymentPackageSnapshot } from './registry-package.js';
 import { recoverRegistryRecords } from './registry-recover.js';
 import { rollbackDeployment, rollbackWithMappedErrors } from './registry-rollback.js';
 import { activeRecord, activeRecordVersion, persistDeployRecord, reconcilePlatformAccountResetRegistryCache, registryAppArchivedAt, registryArchiveApp, registryCustomerAuthRestoreProjections, registryGetApp, registryGetDeployment, registryGetEnvironment, registryListApps, registryListEnvironments, registryRestoreApp, registrySetProductionEnvironment, registrySweepArchived, setRegistryDeploymentLock, } from './registry-state.js';
 import { deploymentStatusFor } from './registry-status.js';
-import { deploymentSourceFor, emptySecretEnvelope, rebindNativeRecords, recordTenant, servedTargetFor, targetForPersistedRecord, tenantDeploymentKey, tenantKey, } from './registry-targets.js';
+import { deploymentSourceFor, emptySecretEnvelope, rebindNativeRecords, servedTargetFor, targetForPersistedRecord, tenantDeploymentKey, tenantKey, } from './registry-targets.js';
 import { withBuiltinStateCatalog } from './state-catalog.js';
 import { deploymentSummary, matchesDeploymentFilter, validateDeploymentListFilter, } from './store/records.js';
 import { InMemoryConfigStore, validateTenantRef, } from './store.js';
@@ -119,6 +119,9 @@ export class ServerRegistry {
                 if (active?.deploymentLock !== undefined)
                     return deploymentLockedConflict();
             }
+            const versionError = await deploymentWriteVersionError(this.#stateView(), safeTenant, safeServerVersion);
+            if (versionError !== undefined)
+                return { ok: false, errors: [versionError] };
             const preflight = await preflightRegistryDeploy({
                 options,
                 serviceCapabilities: this.#serviceCapabilities,
@@ -186,6 +189,8 @@ export class ServerRegistry {
                 if (error instanceof CustomerAuthAudienceConflictError) {
                     return customerAuthAudienceConflictFailure();
                 }
+                if (error instanceof UnsupportedDeploymentRecordVersionError)
+                    return unsupportedDeploymentRecordFailure();
                 if (error instanceof DeploymentLockedError)
                     return deploymentLockedConflict();
                 throw error;
@@ -211,6 +216,8 @@ export class ServerRegistry {
                     if (error instanceof CustomerAuthAudienceConflictError) {
                         return customerAuthAudienceConflictFailure();
                     }
+                    if (error instanceof UnsupportedDeploymentRecordVersionError)
+                        return unsupportedDeploymentRecordFailure();
                     if (error instanceof DeploymentLockedError)
                         return deploymentLockedConflict();
                     throw error;
@@ -262,6 +269,9 @@ export class ServerRegistry {
             if (active?.deploymentLock !== undefined)
                 return deploymentLockedPreflight();
         }
+        const versionError = await deploymentWriteVersionError(this.#stateView(), safeTenant, safeServerVersion);
+        if (versionError !== undefined)
+            return { ok: false, errors: [versionError] };
         const result = await preflightRegistryDeploy({
             options,
             serviceCapabilities: this.#serviceCapabilities,
@@ -305,16 +315,20 @@ export class ServerRegistry {
         }, { tenant, manifest, connectors, hostedAssets, deploymentId, renderAppPackage });
     }
     #compilePersistedRecord(record) {
-        return this.#compileTarget(recordTenant(record), record.manifest, record.connectors === undefined
-            ? undefined
-            : normalizePersistedConnectorsForCompile(record.connectors), record.hostedAssets, false, record.deploymentId);
+        return compilePersistedRegistryRecord(record, this.#compileTarget.bind(this));
     }
     async get(deploymentId) {
         if (this.#records.get(deploymentId)?.archivedAt !== undefined)
             return undefined;
         const cached = this.#servers.get(deploymentId);
-        if (cached)
-            return cached;
+        if (cached) {
+            const record = this.#store
+                ? await this.#store.get(deploymentId)
+                : this.#records.get(deploymentId);
+            return record === undefined || record.archivedAt !== undefined
+                ? undefined
+                : this.#targetForPersistedRecord(record);
+        }
         const inflight = this.#inflight.get(deploymentId);
         if (inflight)
             return inflight;
@@ -495,32 +509,13 @@ export class ServerRegistry {
         });
     }
     async #loadAndCompile(source) {
-        const record = typeof source === 'string'
-            ? this.#store
-                ? await this.#store.get(source)
-                : this.#records.get(source)
-            : source;
-        if (!record)
-            return undefined;
-        const deploymentId = record.deploymentId;
-        if (record.archivedAt !== undefined)
-            return undefined;
-        const built = await this.#compilePersistedRecord(record);
-        if (!built.ok) {
-            throw new Error(`deployment ${deploymentId} failed to recompile (${built.errors.map((e) => e.code).join(',')})`);
-        }
-        const missingCapabilities = missingCapabilityErrors(built.served.artifact.requirements?.capabilities ?? [], this.#serviceCapabilities);
-        if (missingCapabilities.length > 0) {
-            throw new Error(`deployment ${deploymentId} failed capability requirements (${missingCapabilities.map((e) => e.path).join(',')})`);
-        }
-        if (record.active &&
-            (await this.#hasCustomerAuthAudienceConflict(record, built.served.artifact.server.auth))) {
-            return undefined;
-        }
-        const target = servedTargetFor(record, built.served, this.#customerVerifierFactory);
-        this.#servers.set(deploymentId, target);
-        this.#records.set(deploymentId, record);
-        return target;
+        return loadPersistedRegistryTarget(source, {
+            state: this.#stateView(),
+            compile: (record) => this.#compilePersistedRecord(record),
+            capabilities: this.#serviceCapabilities,
+            customerVerifierFactory: this.#customerVerifierFactory,
+            hasCustomerAuthConflict: (record, auth) => this.#hasCustomerAuthAudienceConflict(record, auth),
+        });
     }
     async #hasCustomerAuthAudienceConflict(record, auth) {
         return hasActiveCustomerAuthAudienceConflict(this.#store, this.#records, record, auth);

package/node_modules/@noodle-borg/service/dist/routes/access.js

@@ -1,6 +1,7 @@
 import { normalizeServerVersion } from '@noodle-borg/module';
 import { readJsonBody, sendJson } from '@noodle-borg/transport-http';
 import { accessUpdateRequestSchema } from '@noodle-borg/wire-contracts';
+import { deploymentAuthenticationFor } from '../deployment-authentication.js';
 import { deploymentOwnerSubject } from '../registry-helpers.js';
 import { authorizeControlPlane } from './control-plane.js';
 import { canManageMembers } from './org-admin.js';
@@ -44,6 +45,7 @@ export async function handleAccessUpdate(req, res, registry, gate, controlPlane,
     }
     const accessMode = result.record.accessMode ?? 'owner-only';
     const ownerSubject = deploymentOwnerSubject(result.record);
+    const authentication = deploymentAuthenticationFor(result.record);
     await audit.emit({
         eventType: 'deployment.access.updated',
         org: tenant.org,
@@ -63,6 +65,7 @@ export async function handleAccessUpdate(req, res, registry, gate, controlPlane,
             ...(ownerSubject !== undefined ? { ownerSubject } : {}),
             accessChanged: result.accessChanged,
             ownerChanged: result.ownerChanged,
+            ...(authentication !== undefined ? { authentication, policyChanged: false } : {}),
             changed: result.changed,
         },
     });
@@ -75,6 +78,7 @@ export async function handleAccessUpdate(req, res, registry, gate, controlPlane,
                 ? { serverVersion: result.record.serverVersion }
                 : {}),
             accessMode,
+            ...(authentication !== undefined ? { authentication } : {}),
             ...(ownerSubject !== undefined ? { ownerSubject } : {}),
         },
         previousAccessMode: result.previousAccessMode,
@@ -83,6 +87,7 @@ export async function handleAccessUpdate(req, res, registry, gate, controlPlane,
             : {}),
         accessChanged: result.accessChanged,
         ownerChanged: result.ownerChanged,
+        ...(authentication !== undefined ? { policyChanged: false } : {}),
         changed: result.changed,
     });
 }

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

@@ -1,83 +1,78 @@
 import { readJsonBody, sendJson } from '@noodle-borg/transport-http';
-import { ApplicationActivityListResponseSchema, ApplicationActivityPreviewResponseSchema, ApplicationActivitySettingsResponseSchema, ApplicationActivitySettingsSaveRequestSchema, } from '@noodle-borg/wire-contracts';
-import { ActivityPolicyError } from '../application-activity.js';
+import { ActivityPolicyError, } from '../application-activity.js';
 import { businessGrantAllows } from '../business-information/model.js';
 import { requireIdentity, requireInstallationPermission, } from './business-information.js';
-import { parseBusinessPaging } from './business-information-request.js';
 export async function handleApplicationActivity(req, res, url, ref, deps) {
-    const settings = url.pathname.endsWith('/activity/settings');
-    const exporting = url.pathname.endsWith('/activity/export');
-    const preview = url.pathname.endsWith('/activity/preview');
-    if (req.method !== 'GET' && !(settings && req.method === 'PATCH')) {
-        res.setHeader('allow', settings ? 'GET, PATCH' : 'GET');
+    const coordination = ref.action === 'coordination';
+    const suffix = url.pathname.split('/').at(-1);
+    const action = coordination
+        ? suffix === 'resolve'
+            ? 'coordination-resolve'
+            : 'coordination-list'
+        : suffix === 'settings'
+            ? req.method === 'PATCH'
+                ? 'save-settings'
+                : 'settings'
+            : suffix === 'preview' || suffix === 'export'
+                ? suffix
+                : 'list';
+    const allowed = coordination
+        ? suffix === 'resolve'
+            ? ['POST']
+            : ['GET']
+        : suffix === 'settings'
+            ? ['GET', 'PATCH']
+            : ['GET'];
+    if (!allowed.includes(req.method ?? '')) {
+        res.setHeader('allow', allowed.join(', '));
         return sendJson(res, 405, { error: 'method not allowed' });
     }
     const identity = await requireIdentity(req, res, deps);
     if (identity === false)
         return;
-    const permission = req.method === 'PATCH'
+    const permission = coordination || action === 'save-settings'
         ? 'installation:administer'
-        : exporting
+        : action === 'export'
             ? 'records:export'
             : 'records:read';
-    const authorized = await requireInstallationPermission(res, ref, identity, permission, deps);
+    const authorize = () => requireInstallationPermission(res, ref, identity, permission, deps);
+    const authorized = await authorize();
     if (!authorized)
         return;
-    const reply = async (body) => {
-        if (await requireInstallationPermission(res, ref, identity, permission, deps))
-            sendJson(res, 200, body);
-    };
     res.setHeader('cache-control', 'private, no-store');
     try {
-        const allowedQuery = settings || preview ? [] : ['limit', 'cursor'];
-        for (const key of url.searchParams.keys())
-            if (!allowedQuery.includes(key) || url.searchParams.getAll(key).length !== 1)
-                throw new ActivityPolicyError('activity_invalid');
         if (!deps.activity)
-            throw new ActivityPolicyError('activity_unavailable');
-        const canEdit = businessGrantAllows(authorized.grant, 'installation:administer');
-        if (settings && req.method === 'PATCH') {
-            const body = await readJsonBody(req, deps.maxBody);
-            if (!body.ok)
-                return sendJson(res, body.status, { error: body.error });
-            const parsed = ApplicationActivitySettingsSaveRequestSchema.safeParse(body.value);
-            if (!parsed.success)
-                throw new ActivityPolicyError('activity_invalid');
-            const data = await deps.activity.save(authorized.scope, parsed.data);
+            throw new ActivityPolicyError(coordination ? 'coordination_unavailable' : 'activity_unavailable');
+        let body;
+        if (req.method !== 'GET') {
+            const parsed = await readJsonBody(req, deps.maxBody);
+            if (!parsed.ok)
+                return sendJson(res, parsed.status, { error: parsed.error });
+            body = parsed.value;
+            if (!(await authorize()))
+                return;
+        }
+        const result = await deps.activity.project(authorized.scope, action, {
+            parameters: [...url.searchParams.entries()],
+            body,
+            reviewer: identity.subject,
+            canEdit: businessGrantAllows(authorized.grant, 'installation:administer'),
+        });
+        if ('audit' in result)
             await deps.audit?.emit({
-                eventType: 'config.activity.retention_changed',
+                ...result.audit,
                 org: ref.org,
                 app: authorized.scope.app,
                 env: authorized.scope.env,
                 actorSubject: identity.subject,
-                details: { retentionDays: data.retentionDays },
             });
-            return reply(ApplicationActivitySettingsResponseSchema.parse({ ok: true, data }));
-        }
-        if (preview)
-            return reply(ApplicationActivityPreviewResponseSchema.parse({
-                ok: true,
-                data: await deps.activity.preview(authorized.scope),
-            }));
-        if (settings)
-            return reply(ApplicationActivitySettingsResponseSchema.parse({
-                ok: true,
-                data: (await deps.activity.settings(authorized.scope, canEdit)).projection,
-            }));
-        const paging = parseBusinessPaging(url, 100);
-        if (!paging.ok)
-            return sendJson(res, 400, { error: paging.error });
-        const data = await deps.activity.page(authorized.scope, {
-            purpose: exporting ? 'export' : 'list',
-            limit: paging.value.limit ?? 50,
-            ...(paging.value.cursor === undefined ? {} : { cursor: paging.value.cursor }),
-        });
-        return reply(ApplicationActivityListResponseSchema.parse({ ok: true, data }));
+        if (await authorize())
+            sendJson(res, 200, result.response);
     }
     catch (error) {
         if (!(error instanceof ActivityPolicyError))
             throw error;
-        sendJson(res, error.code === 'activity_unavailable' ? 503 : error.code === 'activity_conflict' ? 409 : 400, { code: error.code, error: error.message });
+        sendJson(res, error.code.endsWith('_unavailable') ? 503 : error.code.endsWith('_conflict') ? 409 : 400, { code: error.code, error: error.message });
     }
 }
 //# sourceMappingURL=business-information-activity.js.map

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

@@ -58,7 +58,8 @@ export function dispatchBusinessInformationRoutes(req, res, url, deps) {
         return false;
     if (installationRef.action === 'notice')
         return run(req, res, deps, () => handleBusinessNotice(req, res, installationRef, deps));
-    if (installationRef.action === 'activity' && installationRef.collection === undefined)
+    if ((installationRef.action === 'activity' || installationRef.action === 'coordination') &&
+        installationRef.collection === undefined)
         return run(req, res, deps, () => handleApplicationActivity(req, res, url, installationRef, deps));
     if (installationRef.action === 'connections')
         return run(req, res, deps, () => handleApplicationConnections(req, res, installationRef, deps));

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

@@ -1,24 +1,58 @@
 import { createHash } from 'node:crypto';
-import { builtInDefinition, } from '../business-information/portable.js';
+import { readJsonBody, sendJson } from '@noodle-borg/transport-http';
+import { SolutionInstallationActivateRequestSchema } from '@noodle-borg/wire-contracts';
+import { sendForbidden } from '../http-util.js';
+import { invalid, methodNotAllowed, requireInstallationPermission, } from './business-information.js';
+import { installationToWire } from './business-information-wire.js';
+import { canManageMembers } from './org-admin.js';
 export function stableInstallationId(org, app, env) {
     return `ins-${createHash('sha256').update(`${org}\0${app}\0${env}`).digest('hex').slice(0, 24)}`;
 }
-export async function resolveInstallDefinition(selector, installingOrg, resolvePrivateDefinition) {
-    if (selector.kind === 'managed') {
-        return builtInDefinition(selector.profileId);
-    }
-    if (selector.publisherOrg !== installingOrg ||
-        selector.publisherOrg === undefined ||
-        selector.app === undefined ||
-        selector.environment === undefined ||
-        selector.deploymentId === undefined) {
-        return undefined;
-    }
-    return resolvePrivateDefinition?.({
-        publisherOrg: selector.publisherOrg,
-        app: selector.app,
-        environment: selector.environment,
-        deploymentId: selector.deploymentId,
+/** Read current activation authority; intake is an independent operator setting. */
+export async function installationProjection(installation, role, identity, deps) {
+    const state = (await deps.readInstallationActivation?.(installation)) ?? 'unavailable';
+    const canRetry = state === 'pending' &&
+        deps.activateInstallation !== undefined &&
+        role === 'administrator' &&
+        (await canManageMembers(deps.controlPlane, installation.scope.org, identity));
+    return {
+        ...installationToWire(installation, role),
+        activation: state === 'pending' ? { state, canRetry } : { state, canRetry: false },
+    };
+}
+export async function retryInstallationActivation(req, res, ref, identity, deps) {
+    if (req.method !== 'POST')
+        return methodNotAllowed(res);
+    const authorized = await requireInstallationPermission(res, ref, identity, 'installation:administer', deps);
+    if (!authorized)
+        return;
+    if (!(await canManageMembers(deps.controlPlane, ref.org, identity)))
+        return sendForbidden(res, 'org owner required');
+    const body = await readJsonBody(req, deps.maxBody);
+    if (!body.ok)
+        return sendJson(res, body.status, { error: body.error });
+    const parsed = SolutionInstallationActivateRequestSchema.safeParse(body.value);
+    if (!parsed.success)
+        return invalid(res, parsed.error);
+    const result = await deps.activateInstallation?.({
+        installation: authorized.installation,
+        actor: identity,
     });
+    if (!result?.ok)
+        return sendJson(res, result?.status ?? 503, {
+            ok: false,
+            code: result?.code ?? 'installation_activation_unavailable',
+            error: result?.message ?? 'The installation is saved. Retry activation when the service is ready.',
+            installationId: authorized.scope.installationId,
+        });
+    const installation = await installationProjection(authorized.installation, authorized.grant.role, identity, deps);
+    if (installation.activation?.state !== 'ready')
+        return sendJson(res, 503, {
+            ok: false,
+            code: 'installation_activation_unavailable',
+            error: 'The installation is saved, but readiness could not be established. Retry activation after the service setup is restored.',
+            installationId: authorized.scope.installationId,
+        });
+    return sendJson(res, 200, { ok: true, data: { installation } });
 }
 //# sourceMappingURL=business-information-installation.js.map

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

@@ -27,7 +27,7 @@ export function parseSolutionInstallationPath(pathname) {
                 ...(connectionAction === undefined ? {} : { connectionAction }),
             };
     }
-    const application = /^\/v1\/orgs\/([^/]+)\/solution-installations\/([^/]+)\/(settings|notice|channels|activity(?:\/(?:settings|export|preview))?)$/.exec(pathname);
+    const application = /^\/v1\/orgs\/([^/]+)\/solution-installations\/([^/]+)\/(activate|settings|notice|channels|operations\/coordination(?:\/resolve)?|activity(?:\/(?:settings|export|preview))?)$/.exec(pathname);
     if (application !== null) {
         const org = decoded(application, 1);
         const installationId = decoded(application, 2);
@@ -36,9 +36,11 @@ export function parseSolutionInstallationPath(pathname) {
             : {
                 org,
                 installationId,
-                action: application[3]?.startsWith('activity')
-                    ? 'activity'
-                    : application[3],
+                action: application[3]?.startsWith('operations/')
+                    ? 'coordination'
+                    : application[3]?.startsWith('activity')
+                        ? 'activity'
+                        : application[3],
             };
     }
     let match = /^\/v1\/orgs\/([^/]+)\/solution-installations$/.exec(pathname);

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

@@ -3,8 +3,9 @@ import { readJsonBody, sendJson } from '@noodle-borg/transport-http';
 import { BusinessInvitationCreateRequestSchema, BusinessInvitationRevokeRequestSchema, formatWireError, } from '@noodle-borg/wire-contracts';
 import { hashToken } from '../oauth/tokens.js';
 import { requireIdentity, requireInstallationPermission, } from './business-information.js';
+import { installationProjection } from './business-information-installation.js';
 import { parseBusinessPaging } from './business-information-request.js';
-import { grantToWire, installationToWire, invitationToWire } from './business-information-wire.js';
+import { grantToWire, invitationToWire } from './business-information-wire.js';
 const HOUR_MS = 60 * 60 * 1_000;
 export async function handleMySolutionInstallations(req, res, deps) {
     if (req.method !== 'GET')
@@ -28,7 +29,7 @@ export async function handleMySolutionInstallations(req, res, deps) {
     sendJson(res, 200, {
         ok: true,
         data: {
-            installations: visible.map(({ installation, grant }) => installationToWire(installation, grant.role)),
+            installations: await Promise.all(visible.map(({ installation, grant }) => installationProjection(installation, grant.role, identity, deps))),
             ...(joined.length > limit && visible.at(-1) !== undefined
                 ? { nextCursor: encodeDiscoveryCursor(visible.at(-1)) }
                 : {}),
@@ -186,7 +187,7 @@ export async function handleBusinessInvitationAccept(req, res, rawToken, deps) {
     sendJson(res, 201, {
         ok: true,
         data: {
-            installation: installationToWire(installation, result.grant.role),
+            installation: await installationProjection(installation, result.grant.role, identity, deps),
             grant: grantToWire(result.grant),
         },
     });