@noodleseed/one 0.163.0 → 0.165.0

package/node_modules/@noodle-borg/service/dist/business-information/managed-solution-executable.js

@@ -10,6 +10,16 @@ export function managedSolutionManifest(definition) {
     const collection = definition.collections.find((entry) => entry.key === blueprint.collection);
     if (collection === undefined)
         throw new Error('Managed solution executable collection is missing');
+    const recordInput = collectionToPublicWire(collection).recordSchema;
+    const inputSchema = 'followUpContact' in blueprint
+        ? {
+            ...recordInput,
+            required: [
+                ...(Array.isArray(recordInput.required) ? recordInput.required : []),
+                'contact_email',
+            ],
+        }
+        : recordInput;
     return {
         manifestVersion: '2',
         server: {
@@ -46,7 +56,7 @@ export function managedSolutionManifest(definition) {
                 name: blueprint.tool,
                 title: blueprint.title,
                 description: blueprint.description,
-                inputSchema: collectionToPublicWire(collection).recordSchema,
+                inputSchema,
                 outputSchema: RECORD_OPERATION_SIGNATURES.submit_record?.output,
                 annotations: {
                     confirm: true,

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

@@ -47,13 +47,13 @@ export function businessGrantAllows(grant, permission) {
         grant.revokedAt === undefined &&
         permissionsForBusinessRole(grant.role).includes(permission));
 }
-export function normalizeInstallationInput(input) {
+export function normalizeInstallationInput(input, resolveManaged = builtInDefinition) {
     const scope = { ...validateScope(input.scope) };
     if ((input.profileKey === undefined) === (input.definition === undefined)) {
         throw new Error('installation requires exactly one managed profile or private definition');
     }
     const definition = input.definition ??
-        builtInDefinition(input.profileKey);
+        resolveManaged(input.profileKey);
     validateDefinition(definition);
     const managedCollections = [...new Set(input.managedCollections)].sort();
     for (const collectionKey of managedCollections) {

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

@@ -1,6 +1,6 @@
 export * from './collection-controls.js';
 export * from './contracts.js';
-export * from './definition-resolver.js';
+export { privateDefinitionFromDeployment, } from './definition-resolver.js';
 export * from './in-memory-store.js';
 export * from './legacy-request-migration.js';
 export * from './managed-releases.js';

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

@@ -1,4 +1,5 @@
 import { createHash } from 'node:crypto';
+import { validateJsonSchema as validateSchema } from '@noodle-borg/compiler';
 import { managedSolutionBlueprint, managedSolutionVariables, } from './managed-solution-blueprints.js';
 import { PayloadValidationError, validateManagedPayload, validateScalar } from './validation.js';
 const requestSchema = (required, properties) => ({
@@ -73,6 +74,12 @@ export const BUILT_IN_SOLUTION_PROFILE_RELEASES = {
         { key: 'travel', version: 1, label: 'Travel', collections: [travelV1] },
         { key: 'travel', version: 2, label: 'Travel', collections: [travelV2] },
         { key: 'travel', version: 3, label: 'Travel', collections: [lightweightCollection(travelV2)] },
+        {
+            key: 'travel',
+            version: 4,
+            label: 'Travel',
+            collections: [followUpCollection(lightweightCollection(travelV2))],
+        },
     ],
     b2b_saas: [{ key: 'b2b_saas', version: 1, label: 'B2B SaaS', collections: [service] }],
     ecommerce: [
@@ -92,6 +99,12 @@ export const BUILT_IN_SOLUTION_PROFILE_RELEASES = {
             label: 'Restaurant',
             collections: [lightweightCollection(restaurant)],
         },
+        {
+            key: 'restaurant',
+            version: 3,
+            label: 'Restaurant',
+            collections: [followUpCollection(lightweightCollection(restaurant))],
+        },
     ],
 };
 export const BUILT_IN_SOLUTION_PROFILES = {
@@ -189,7 +202,7 @@ function collectionDefinition(profile) {
                 management: profile.management,
                 publicFields: profile.publicFields ?? [],
                 editableFields: Object.keys(profile.schema.properties),
-                fields: { status: { label: 'Status' } },
+                fields: { status: { label: 'Status' }, ...profile.fields },
                 filterFields: ['status'],
                 sortFields: ['status'],
             }),
@@ -213,6 +226,26 @@ function lightweightCollection(previous) {
         publicFields: Object.keys(previous.schema.properties),
     };
 }
+/** Optional storage preserves historical records; the new application tool asks for a reply route. */
+function followUpCollection(previous) {
+    return {
+        ...previous,
+        ...collection(previous.key, previous.labels, {
+            ...previous.schema,
+            properties: {
+                ...previous.schema.properties,
+                contact_email: { type: 'string', format: 'email', minLength: 3, maxLength: 254 },
+            },
+        }, previous.schemaVersion + 1),
+        publicFields: [...(previous.publicFields ?? []), 'contact_email'],
+        fields: {
+            contact_email: {
+                label: 'Reply email',
+                help: 'The address provided by the guest for staff follow-up. This address has not been verified.',
+            },
+        },
+    };
+}
 function validateJsonSchema(schema, payload) {
     for (const required of schema.required) {
         if (!(required in payload)) {
@@ -236,6 +269,9 @@ function validateJsonSchema(schema, payload) {
         if (property.enum !== undefined && !property.enum.includes(value)) {
             throw new PayloadValidationError('invalid_json', `managed payload field "${key}" has an unsupported value`);
         }
+        if (property.format !== undefined && validateSchema(property, value).length > 0) {
+            throw new PayloadValidationError('invalid_json', `managed payload field "${key}" has an invalid format`);
+        }
     }
 }
 function stableJson(value) {

package/node_modules/@noodle-borg/service/dist/credential-binding-index.js

@@ -27,7 +27,10 @@ export function buildCredentialBindingIndex(artifact) {
             return [];
         return source.scan.resolved ? [source.scan] : [];
     });
-    const operationRefs = [...fulfilments.flatMap(resolvedOperationRefs), ...sourceRefs];
+    const operationRefs = nestedReferences([
+        ...fulfilments.flatMap(resolvedOperationRefs),
+        ...sourceRefs,
+    ]);
     for (const ref of operationRefs) {
         const credentialBinding = ref.credentialBinding;
         if (credentialBinding === undefined)
@@ -67,4 +70,19 @@ export function buildCredentialBindingIndex(artifact) {
         googleWorkloadIdentity: [...googleWorkloadIdentity.values()],
     };
 }
+function nestedReferences(roots) {
+    const output = [];
+    const queue = roots.map((ref) => ({ ref, depth: 0 }));
+    for (let index = 0; index < queue.length; index += 1) {
+        const entry = queue[index];
+        if (!entry)
+            continue;
+        if (entry.depth > 32 || queue.length > 65536)
+            throw new Error('Invalid compiled connector dependency graph');
+        output.push(entry.ref);
+        for (const child of entry.ref.calls ?? [])
+            queue.push({ ref: child, depth: entry.depth + 1 });
+    }
+    return output;
+}
 //# sourceMappingURL=credential-binding-index.js.map

package/node_modules/@noodle-borg/service/dist/deployment-execution.js

@@ -266,7 +266,7 @@ export async function executeAuthorizedDeployment(input, dependencies) {
             assets: hostedAssets,
         });
     }
-    const embedId = await provisionPublicEmbed(registry, options, tenant, result.deploymentId);
+    const embedId = await provisionPublicEmbed(registry, options, tenant, result.deploymentId, input.allowRevokedEmbedReplacement);
     return { ok: true, result, ...(embedId === undefined ? {} : { embedId }) };
 }
 function reject(status, body) {

package/node_modules/@noodle-borg/service/dist/operation-coordination.js

@@ -0,0 +1,185 @@
+import { createHash, createHmac, randomUUID } from 'node:crypto';
+import { canonicalJson } from '@noodle-borg/compiler';
+/** The same opaque resource identity is used by ordinary dispatch and reviewed custody migrations. */
+export function deriveOperationCoordinationResource(input) {
+    if (typeof input.identityKey !== 'string' ||
+        input.identityKey.length < 32 ||
+        !/^[A-Za-z0-9_-]{1,128}$/.test(input.connectionId) ||
+        !/^[A-Za-z0-9_-]{1,80}$/.test(input.namespace) ||
+        typeof input.key !== 'string' ||
+        input.key.length < 1 ||
+        input.key.length > 2048 ||
+        ![input.scope.org, input.scope.app, input.scope.env, input.scope.installationId].every((value) => typeof value === 'string' && value.length > 0 && value.length <= 256))
+        throw new Error('Invalid coordination resource authority');
+    return createHmac('sha256', input.identityKey)
+        .update(canonicalJson({
+        scope: input.scope,
+        connectionId: input.connectionId,
+        namespace: input.namespace,
+        key: input.key,
+    }))
+        .digest('hex');
+}
+/** No business payloads, provider-specific logic, automatic retries or time-based unlocks. */
+export function createOperationCoordinationPort(options) {
+    if (options.identityKey.length < 32 || !/^[A-Za-z0-9_-]{16,128}$/.test(options.epoch))
+        throw new Error('Invalid coordination authority configuration');
+    const now = () => options.now?.() ?? Date.now();
+    const authority = async (intent, generation) => {
+        const current = options.connectionGeneration(intent.connectionId);
+        if (!current ||
+            (generation !== undefined && current !== generation) ||
+            !(await options.authorize()))
+            throw new Error('Original operation authority unavailable');
+        return current;
+    };
+    return {
+        async acquire(intent) {
+            validateIntent(intent);
+            const generation = await authority(intent);
+            // Deliberately excludes deployment, connection generation and execution epoch: replacing an
+            // artifact or reconnecting cannot bypass a held resource. Tenant/app/environment remain isolated.
+            const resource = deriveOperationCoordinationResource({
+                scope: options.scope,
+                connectionId: intent.connectionId,
+                namespace: intent.namespace,
+                key: intent.key,
+                identityKey: options.identityKey,
+            });
+            const startedAt = now();
+            const record = {
+                scope: options.scope,
+                resource,
+                token: randomUUID(),
+                epoch: options.epoch,
+                generation,
+                reference: intent.reference,
+                operationDigest: createHash('sha256').update(intent.id).digest('hex'),
+                startedAt,
+                deadline: startedAt + intent.executionBoundMs,
+                state: 'executing',
+            };
+            const claimed = await options.store.claim(record);
+            const previous = claimed.previous;
+            const recoverable = !claimed.acquired &&
+                previous !== undefined &&
+                previous.generation === generation &&
+                previous.epoch === options.epoch &&
+                (previous.state === 'unknown' || previous.deadline <= startedAt);
+            let resolved = false;
+            let finished = false;
+            return {
+                acquired: claimed.acquired,
+                ...(recoverable
+                    ? {
+                        previous: {
+                            reference: previous.reference,
+                            operationDigest: previous.operationDigest,
+                        },
+                    }
+                    : {}),
+                async finish(evidence) {
+                    if (!claimed.acquired || finished)
+                        return;
+                    finished = true;
+                    // No expiry authorizes a retry. Only proven completion or proof of no dispatched effect
+                    // releases custody; an outer success message without explicit evidence remains unknown.
+                    if (evidence.outcome === 'completed' || evidence.outcome === 'rejected') {
+                        await options.store.release(resource, record.token, evidence.outcome);
+                    }
+                    else
+                        await options.store.markUnknown(resource, record.token);
+                },
+                async resolvePrevious() {
+                    if (!recoverable || !previous || resolved)
+                        throw new Error('Prior operation cannot be resolved');
+                    await authority(intent, generation);
+                    if (now() > record.deadline)
+                        throw new Error('Recovery execution expired');
+                    if (!(await options.store.release(resource, previous.token, 'source_verified')))
+                        throw new Error('Prior operation changed before resolution');
+                    resolved = true;
+                },
+            };
+        },
+    };
+}
+function validateIntent(intent) {
+    if (!/^[a-f0-9]{64}$/.test(intent.id) ||
+        !/^[A-Za-z0-9_-]{1,128}$/.test(intent.connectionId) ||
+        !/^[A-Za-z0-9_-]{1,80}$/.test(intent.namespace) ||
+        typeof intent.key !== 'string' ||
+        intent.key.length < 1 ||
+        intent.key.length > 2048 ||
+        typeof intent.reference !== 'string' ||
+        !/^[A-Za-z0-9._:@/-]{1,256}$/.test(intent.reference) ||
+        intent.reference.includes('://') ||
+        !Number.isSafeInteger(intent.executionBoundMs) ||
+        intent.executionBoundMs < 1 ||
+        intent.executionBoundMs > 120000)
+        throw new Error('Invalid coordination intent');
+}
+/** Explicit local/test composition; hosted production supplies the PostgreSQL implementation. */
+export class InMemoryOperationCoordinationStore {
+    now;
+    records = new Map();
+    receipts = [];
+    constructor(now = Date.now) {
+        this.now = now;
+    }
+    async claim(record) {
+        const previous = this.records.get(record.resource);
+        if (previous && canonicalJson(previous.scope) !== canonicalJson(record.scope))
+            throw new Error('Coordination scope mismatch');
+        if (previous)
+            return { acquired: false, previous: structuredClone(previous) };
+        this.records.set(record.resource, structuredClone(record));
+        return { acquired: true };
+    }
+    async markUnknown(resource, token) {
+        const record = this.records.get(resource);
+        if (record?.token === token)
+            this.records.set(resource, { ...record, state: 'unknown' });
+    }
+    async release(resource, token, resolution) {
+        if (!['completed', 'rejected', 'source_verified'].includes(resolution))
+            throw new Error('Invalid coordination resolution');
+        const record = this.records.get(resource);
+        if (!record || record.token !== token)
+            return false;
+        if (resolution === 'source_verified')
+            this.receipts.push({ record: structuredClone(record), resolution, resolvedAt: this.now() });
+        return this.records.delete(resource);
+    }
+    async list(scope, limit = 100, beforeResource) {
+        if (!Number.isSafeInteger(limit) ||
+            limit < 1 ||
+            limit > 100 ||
+            (beforeResource !== undefined && !/^[a-f0-9]{64}$/.test(beforeResource)))
+            throw new Error('Invalid coordination paging');
+        return [...this.records.values()]
+            .filter((record) => canonicalJson(record.scope) === canonicalJson(scope) &&
+            (!beforeResource || record.resource > beforeResource))
+            .sort((a, b) => a.resource.localeCompare(b.resource))
+            .slice(0, limit)
+            .map((record) => structuredClone(record));
+    }
+    async resolve(scope, resource, token, review) {
+        if (![review.reviewer, review.reason].every((value) => typeof value === 'string' && value.trim().length > 0 && value.length <= 256))
+            throw new Error('Invalid coordination review');
+        const record = this.records.get(resource);
+        if (!record ||
+            record.token !== token ||
+            canonicalJson(record.scope) !== canonicalJson(scope) ||
+            (record.state === 'executing' && record.deadline > this.now()))
+            return false;
+        this.receipts.push({
+            record: structuredClone(record),
+            resolution: 'reviewed',
+            ...review,
+            resolvedAt: this.now(),
+        });
+        return this.records.delete(resource);
+    }
+}
+//# sourceMappingURL=operation-coordination.js.map

package/node_modules/@noodle-borg/service/dist/operation-evidence.js

@@ -20,13 +20,14 @@ export function createOperationEvidencePort(options) {
                 bound >= days * 86_400_000 ||
                 !(await options.authorize(intent)))
                 throw new Error('Operation evidence authority unavailable');
-            const connectionId = intent.operation.credentialBinding?.connectionId;
+            const connectionId = intent.operation.credentialBinding?.connectionId ?? intent.connectionId;
             const generation = connectionId === undefined ? undefined : options.connectionGeneration(connectionId);
             if (connectionId !== undefined && generation === undefined)
                 throw new Error('Original connected account unavailable');
             const record = {
                 scope: options.scope,
                 id: intent.id,
+                ...(intent.parentId === undefined ? {} : { parentId: intent.parentId }),
                 lease: randomUUID(),
                 epoch: options.epoch,
                 deploymentId: options.deploymentId,
@@ -44,6 +45,7 @@ export function createOperationEvidencePort(options) {
                     input: intent.arguments,
                     caller: intent.caller ?? null,
                     revision: intent.executionRevision ?? null,
+                    parentId: intent.parentId ?? null,
                     generation: generation ?? null,
                 }),
                 startedAt,

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);