@noodleseed/one 0.177.0 → 0.178.0

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

@@ -1,25 +1,38 @@
 import { readJsonBody, sendJson } from '@noodle-borg/transport-http';
+import { ConversationReviewRequestSchema } from '@noodle-borg/wire-contracts';
 import { ConversationHistoryError, } from '../conversation-history/operator.js';
 import { requireIdentity, requireInstallationPermission, } from './business-information.js';
-/** ADR 0241 decision 10: readers see text; only export and erasure need Owner/Administrator authority. */
+/**
+ * ADR 0241 decision 10: readers see text; reviewing and noting need the record-handling permissions an
+ * Operator holds; only export and erasure need Owner/Administrator authority.
+ */
 const PERMISSIONS = {
     list: 'records:read',
     show: 'records:read',
     export: 'records:export',
     forget: 'records:delete',
 };
+const METHODS = { list: ['GET'], show: ['GET', 'PATCH'], export: ['GET'], forget: ['POST'] };
 export async function handleApplicationConversations(req, res, url, ref, deps) {
-    const action = ref.conversationAction ?? 'list';
-    const method = action === 'forget' ? 'POST' : 'GET';
-    if (req.method !== method) {
-        res.setHeader('allow', method);
+    const route = ref.conversationAction ?? 'list';
+    const methods = METHODS[route];
+    if (!methods.includes(req.method ?? '')) {
+        res.setHeader('allow', methods.join(', '));
         return sendJson(res, 405, { error: 'method not allowed' });
     }
+    const action = req.method === 'PATCH' ? 'review' : route;
     const identity = await requireIdentity(req, res, deps);
     if (identity === false)
         return;
-    const permission = PERMISSIONS[action];
-    const authorize = () => requireInstallationPermission(res, ref, identity, permission, deps);
+    // A review's permissions follow its fields, so it is read-authorized before its body is parsed.
+    let permissions = [PERMISSIONS[route]];
+    const authorize = async () => {
+        const [last = PERMISSIONS[route], ...earlier] = [...permissions].reverse();
+        for (const permission of earlier)
+            if (!(await requireInstallationPermission(res, ref, identity, permission, deps)))
+                return false;
+        return requireInstallationPermission(res, ref, identity, last, deps);
+    };
     const authorized = await authorize();
     if (!authorized)
         return;
@@ -28,22 +41,34 @@ export async function handleApplicationConversations(req, res, url, ref, deps) {
         if (!deps.conversations)
             throw new ConversationHistoryError('conversation_unavailable');
         let body;
-        if (method === 'POST') {
+        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 (action === 'review') {
+                const review = ConversationReviewRequestSchema.safeParse(body);
+                if (!review.success)
+                    throw new ConversationHistoryError('conversation_invalid');
+                permissions = [
+                    ...(review.data.reviewStatus === undefined ? [] : ['records:status']),
+                    ...(review.data.note === undefined ? [] : ['records:note']),
+                ];
+            }
             if (!(await authorize()))
                 return;
         }
+        const fence = permissions.at(-1) ?? PERMISSIONS[route];
         const result = await deps.conversations.project(authorized.scope, action, {
             parameters: [...url.searchParams.entries()],
             ...(ref.conversationId === undefined ? {} : { conversationId: ref.conversationId }),
             body,
-        }, (operation) => deps.store.staff.run(authorized.scope, identity.subject, permission, operation));
-        if ('audit' in result && result.audit)
+            actor: identity.subject,
+            ...(deps.forgetWhatsApp ? { forgetWorkingMemory: deps.forgetWhatsApp } : {}),
+        }, (operation) => deps.store.staff.run(authorized.scope, identity.subject, fence, operation));
+        for (const event of result.audits)
             await deps.audit?.emit({
-                ...result.audit,
+                ...event,
                 org: ref.org,
                 app: authorized.scope.app,
                 env: authorized.scope.env,

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

@@ -9,7 +9,7 @@ import { SourceCapacityError } from '../business-information/source-custody-budg
 import { BusinessWorkspaceError } from '../business-workspaces/contracts.js';
 import { respondRouteError } from '../http-util.js';
 import { handleBusinessGrants, handleManagedRecords, handleSolutionCatalog, handleSolutionInstallations, } from './business-information.js';
-import { handleApplicationActivity, } from './business-information-activity.js';
+import { handleApplicationActivity } from './business-information-activity.js';
 import { handleBusinessChannels, } from './business-information-channels.js';
 import { handleApplicationConnectionCallback, handleApplicationConnections, } from './business-information-connections.js';
 import { handleApplicationConversations, } from './business-information-conversations.js';
@@ -79,7 +79,9 @@ export function dispatchBusinessInformationRoutes(req, res, url, deps) {
         return run(req, res, deps, () => handleNativeRecordLifecycle(req, res, installationRef, deps));
     if (installationRef.action === 'notice')
         return run(req, res, deps, () => handleBusinessNotice(req, res, installationRef, deps));
-    if ((installationRef.action === 'activity' || installationRef.action === 'coordination') &&
+    if ((installationRef.action === 'activity' ||
+        installationRef.action === 'history' ||
+        installationRef.action === 'coordination') &&
         installationRef.collection === undefined)
         return run(req, res, deps, () => handleApplicationActivity(req, res, url, installationRef, deps));
     if (installationRef.action === 'conversations')

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

@@ -43,7 +43,7 @@ export function parseSolutionInstallationPath(pathname) {
                         : { conversationAction: 'show', conversationId: segment }),
             };
     }
-    const application = /^\/v1\/orgs\/([^/]+)\/solution-installations\/([^/]+)\/(activate|settings|notice|record-lifecycle|channels|operations\/coordination(?:\/resolve)?|activity(?:\/(?:settings|export|preview))?)$/.exec(pathname);
+    const application = /^\/v1\/orgs\/([^/]+)\/solution-installations\/([^/]+)\/(activate|settings|notice|record-lifecycle|channels|operations\/coordination(?:\/resolve)?|history\/settings|activity(?:\/(?:export|preview))?)$/.exec(pathname);
     if (application !== null) {
         const org = decoded(application, 1);
         const installationId = decoded(application, 2);
@@ -56,7 +56,9 @@ export function parseSolutionInstallationPath(pathname) {
                     ? 'coordination'
                     : application[3]?.startsWith('activity')
                         ? 'activity'
-                        : application[3],
+                        : application[3] === 'history/settings'
+                            ? 'history'
+                            : application[3],
             };
     }
     let match = /^\/v1\/orgs\/([^/]+)\/solution-installations$/.exec(pathname);

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

@@ -68,6 +68,10 @@ export async function handleSolutionInstallations(req, res, ref, deps) {
                 code: 'installation_conflict',
             });
         }
+        // Only a created installation opts in (ADR 0241 decision 8), before activation can read the setting.
+        // Without a verified allowance it stays not enabled: recording nothing is the safe failure.
+        if (result.disposition === 'created')
+            await deps.activity?.initializeHistory(result.installation.scope).catch(() => false);
         const grant = await resolveBusinessStaffGrant(deps, result.installation.scope, identity.subject);
         if (grant === undefined || grant.revokedAt !== undefined) {
             return sendForbidden(res, 'business grant required');

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

@@ -209,16 +209,6 @@ async function operate(req, res, url, tenant, path, runtime, grants) {
         }
         return respond(res, wire.WhatsAppCooldownResponseSchema, await channels.cooldown(id, value));
     }
-    if (kind === 'participants' &&
-        value &&
-        participant.test(value) &&
-        action === 'forget' &&
-        req.method === 'POST') {
-        await body(req, wire.WhatsAppEmptyRequestSchema);
-        await channels.forget(id, value, identity.subject, idempotency);
-        await audit('conversation_forgotten');
-        return sendJson(res, 200, { ok: true });
-    }
     if (kind === 'events' &&
         (!value || eventId.test(value)) &&
         (read || (action === 'reconcile' && req.method === 'POST'))) {

package/node_modules/@noodle-borg/service/dist/service-history-projections.js

@@ -1,24 +1,52 @@
 import { randomBytes } from 'node:crypto';
-import { ApplicationActivity } from './application-activity.js';
+import { ActivityPolicyError, ApplicationActivity } from './application-activity.js';
+import { historyDisabledSurfaces } from './application-history-settings.js';
 import { ApplicationConversations } from './conversation-history/operator.js';
 /** Installation history projections over the optional durable stores the service was given. */
-export function createHistoryProjections(options, moduleHost) {
+export function createHistoryProjections(options, moduleHost, installations, registry) {
+    const history = options.conversationHistory;
     const activity = options.operationEvidence === undefined
         ? undefined
         : new ApplicationActivity({
             ...options.operationEvidence,
             allowance: async (org, request) => moduleHost.resolveActivityHistoryAllowance?.(org, request),
+            ...(history === undefined ? {} : { conversationHistory: history.store }),
+            historyDisabledSurfaces: async (scope) => historyDisabledSurfaces((await registry.getActiveByTenant(scope))?.served.artifact.server.assistant),
         });
-    const history = options.conversationHistory;
+    const conversationPolicy = history?.policy ?? settingsConversationPolicy(installations, activity);
     const conversations = history === undefined
         ? undefined
         : new ApplicationConversations({
             store: history.store,
+            policy: conversationPolicy,
             identityKey: history.identityKey ?? randomBytes(32).toString('hex'),
             ...(options.clock === undefined
                 ? {}
                 : { now: () => options.clock?.().getTime() ?? Date.now() }),
         });
-    return { activity, conversations };
+    return { activity, conversations, conversationPolicy };
+}
+/**
+ * Capture follows the installation history setting under the live plan allowance (ADR 0241). A tenant
+ * with no single installation, setting opt-in or verified allowance records nothing, and the read never
+ * creates a setting.
+ */
+function settingsConversationPolicy(installations, activity) {
+    return async (tenant) => {
+        if (!installations || !activity)
+            return undefined;
+        const matching = (await installations.listInstallations(tenant.org)).filter((item) => item.scope.app === tenant.app && item.scope.env === tenant.env);
+        const installation = matching.length === 1 ? matching[0] : undefined;
+        if (!installation)
+            return undefined;
+        try {
+            return await activity.conversationPolicy(installation.scope);
+        }
+        catch (error) {
+            if (error instanceof ActivityPolicyError)
+                return undefined;
+            throw error;
+        }
+    };
 }
 //# sourceMappingURL=service-history-projections.js.map

package/node_modules/@noodle-borg/service/dist/service-resource-cleanup.js

@@ -24,6 +24,38 @@ export async function closeServiceResources(input) {
     if (errors.length > 0)
         throw new AggregateError(errors, 'service resource cleanup failed');
 }
+/**
+ * Clean up after a failed boot without letting a cleanup failure replace the error that aborted startup:
+ * operators must see the bind or boot cause, while the cleanup failure is still logged.
+ */
+export async function cleanupAfterStartupFailure(logger, phase, cleanup) {
+    try {
+        await cleanup();
+    }
+    catch (error) {
+        const code = firstErrorCode(error);
+        logger.error('service.startup_cleanup_failed', {
+            phase,
+            name: error instanceof Error ? error.name : 'unknown',
+            ...(code === undefined ? {} : { code }),
+        });
+    }
+}
+/** The first scalar driver/system code, searching nested cleanup aggregates depth-first. */
+function firstErrorCode(error, depth = 0) {
+    if (typeof error !== 'object' || error === null || depth > 4)
+        return undefined;
+    if ('code' in error && typeof error.code === 'string')
+        return error.code;
+    if (!(error instanceof AggregateError))
+        return undefined;
+    for (const nested of error.errors) {
+        const code = firstErrorCode(nested, depth + 1);
+        if (code !== undefined)
+            return code;
+    }
+    return undefined;
+}
 export function listenHttpServer(http, port, host) {
     return new Promise((resolve, reject) => {
         const onError = (error) => {

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

@@ -14,7 +14,7 @@ import { assistantRouteDependencies } from './assistant-composition.js';
 import { resolveBuildInfo } from './build-info.js';
 import { createBusinessInformationRuntime, resolvePrivateInstallationDefinition, } from './business-information-runtime.js';
 import { serviceCapabilityReport } from './capabilities.js';
-import { createWhatsAppRuntime } from './channels/composition.js';
+import { createWhatsAppRuntime, whatsappBusinessRoutes } from './channels/composition.js';
 import { rejectIncompatibleCli } from './client-compatibility.js';
 import { createDataPlaneMembershipAuthorizer } from './data-plane-membership.js';
 import { DEVELOPER_MCP_PATH, handleDeveloperMcpRequest } from './developer-mcp/mount.js';
@@ -95,7 +95,7 @@ export function createServiceHandler(registry, options = {}) {
     activeAudit = audit;
     const { publicTenantRouting } = mcp.mcpRoutingOptions(options, controlPlane);
     const resolveEndpointOptions = (org) => mcp.endpointUrlOptionsForOrg(options, controlPlane, org);
-    const { activity, conversations } = createHistoryProjections(options, moduleHost);
+    const { activity, conversations, conversationPolicy } = createHistoryProjections(options, moduleHost, businessInformationStore, registry);
     const withIntentMode = createIntentTargetResolver(intentSettings, intentPreviewOrgs);
     const { activateInstallation, readInstallationActivation, resolveRuntimeTarget, businessOnboarding, } = createApplicationServingRuntime(registry, providerOptions, controlPlane, audit, activity);
     const runtimeTarget = async (target) => target === undefined ? undefined : resolveRuntimeTarget(target);
@@ -192,6 +192,7 @@ export function createServiceHandler(registry, options = {}) {
         maxBody,
         serviceBase: (request) => options.publicBaseUrl ?? baseFromRequest(request, tls),
         logger,
+        conversationPolicy,
     });
     const whatsapp = createWhatsAppRuntime(options.whatsapp, assistantDeps, {
         allowance: moduleHost.resolveActivityHistoryAllowance,
@@ -302,7 +303,7 @@ export function createServiceHandler(registry, options = {}) {
             dispatchBusinessInformationRoutes(req, res, url, {
                 pageOrigin: options.businessPageOrigin,
                 pageServiceUrl: options.publicBaseUrl,
-                ...(whatsapp ? { readWhatsApp: whatsapp.projection.bind(whatsapp) } : {}),
+                ...whatsappBusinessRoutes(whatsapp),
                 store: businessInformationStore,
                 ...(options.businessAuthoring ? { workspaces: options.businessAuthoring.workspaces } : {}),
                 ...(businessOnboarding ? { businessOnboarding } : {}),

package/node_modules/@noodle-borg/service/package.json

@@ -41,7 +41,7 @@
     "@noodle-borg/managed-capabilities": "0.0.0",
     "@modelcontextprotocol/sdk": "^1.29.0",
     "@noodle-borg/admission-limits": "0.0.0",
-    "@noodle-borg/agent-kit": "0.107.0",
+    "@noodle-borg/agent-kit": "0.108.0",
     "@noodle-borg/app-package": "0.0.0",
     "@noodle-borg/assistant-gateway": "0.0.0",
     "@noodle-borg/auth": "0.0.0",

package/node_modules/@noodle-borg/wire-contracts/dist/application-activity.d.ts

@@ -42,25 +42,6 @@ export declare const ApplicationActivityListResponseSchema: z.ZodObject<{
         historyDays: z.ZodNumber;
     }, z.core.$strict>;
 }, z.core.$strict>;
-export declare const ApplicationActivitySettingsSchema: z.ZodObject<{
-    revision: z.ZodString;
-    retentionDays: z.ZodNumber;
-    maximumDays: z.ZodNumber;
-    canEdit: z.ZodBoolean;
-}, z.core.$strict>;
-export declare const ApplicationActivitySettingsResponseSchema: z.ZodObject<{
-    ok: z.ZodLiteral<true>;
-    data: z.ZodObject<{
-        revision: z.ZodString;
-        retentionDays: z.ZodNumber;
-        maximumDays: z.ZodNumber;
-        canEdit: z.ZodBoolean;
-    }, z.core.$strict>;
-}, z.core.$strict>;
-export declare const ApplicationActivitySettingsSaveRequestSchema: z.ZodObject<{
-    expectedRevision: z.ZodString;
-    retentionDays: z.ZodNumber;
-}, z.core.$strict>;
 /** Clients tolerate additive response fields; writes and server output remain strict. */
 export declare const ApplicationActivityListClientResponseSchema: z.ZodObject<{
     ok: z.ZodLiteral<true>;
@@ -87,15 +68,6 @@ export declare const ApplicationActivityListClientResponseSchema: z.ZodObject<{
         historyDays: z.ZodNumber;
     }, z.core.$strip>;
 }, z.core.$strip>;
-export declare const ApplicationActivitySettingsClientResponseSchema: z.ZodObject<{
-    ok: z.ZodLiteral<true>;
-    data: z.ZodObject<{
-        revision: z.ZodString;
-        retentionDays: z.ZodNumber;
-        maximumDays: z.ZodNumber;
-        canEdit: z.ZodBoolean;
-    }, z.core.$strip>;
-}, z.core.$strip>;
 export declare const ApplicationActivityPreviewResponseSchema: z.ZodObject<{
     ok: z.ZodLiteral<true>;
     data: z.ZodDiscriminatedUnion<[z.ZodObject<{

package/node_modules/@noodle-borg/wire-contracts/dist/application-activity.js

@@ -18,20 +18,6 @@ export const ApplicationActivityListResponseSchema = z.strictObject({
         historyDays: z.number().int().min(1).max(365),
     }),
 });
-export const ApplicationActivitySettingsSchema = z.strictObject({
-    revision: z.string().regex(/^[a-f0-9]{64}$/),
-    retentionDays: z.number().int().min(1).max(365),
-    maximumDays: z.number().int().min(1).max(365),
-    canEdit: z.boolean(),
-});
-export const ApplicationActivitySettingsResponseSchema = z.strictObject({
-    ok: z.literal(true),
-    data: ApplicationActivitySettingsSchema,
-});
-export const ApplicationActivitySettingsSaveRequestSchema = z.strictObject({
-    expectedRevision: z.string().regex(/^[a-f0-9]{64}$/),
-    retentionDays: z.number().int().min(1).max(365),
-});
 /** Clients tolerate additive response fields; writes and server output remain strict. */
 export const ApplicationActivityListClientResponseSchema = z.object({
     ok: z.literal(true),
@@ -45,10 +31,6 @@ export const ApplicationActivityListClientResponseSchema = z.object({
             .max(100),
     }),
 });
-export const ApplicationActivitySettingsClientResponseSchema = z.object({
-    ok: z.literal(true),
-    data: z.object(ApplicationActivitySettingsSchema.shape),
-});
 const ActivityPreviewScenarioSchema = z.strictObject({
     id: z.string().min(1).max(128),
     label: z.string().min(1).max(128),

package/node_modules/@noodle-borg/wire-contracts/dist/application-history-settings.d.ts

@@ -0,0 +1,190 @@
+import { z } from 'zod';
+export declare const HistorySourcesSchema: z.ZodObject<{
+    websiteVisitors: z.ZodBoolean;
+    signedInCustomers: z.ZodBoolean;
+    whatsapp: z.ZodBoolean;
+}, z.core.$strict>;
+/** A surface the application declared `history: false` on, named by its authoring constructor. */
+export declare const ApplicationHistoryDisabledSurfaceSchema: z.ZodEnum<{
+    publicWebsite: "publicWebsite";
+    authenticatedWebsite: "authenticatedWebsite";
+    publicMessaging: "publicMessaging";
+}>;
+export declare const ApplicationHistorySettingsSchema: z.ZodObject<{
+    revision: z.ZodString;
+    canEdit: z.ZodBoolean;
+    activity: z.ZodObject<{
+        retentionDays: z.ZodNumber;
+        maximumDays: z.ZodNumber;
+        defaultDays: z.ZodNumber;
+    }, z.core.$strict>;
+    conversations: z.ZodObject<{
+        state: z.ZodEnum<{
+            not_enabled: "not_enabled";
+            off: "off";
+            on: "on";
+        }>;
+        retentionDays: z.ZodOptional<z.ZodNumber>;
+        sources: z.ZodObject<{
+            websiteVisitors: z.ZodBoolean;
+            signedInCustomers: z.ZodBoolean;
+            whatsapp: z.ZodBoolean;
+        }, z.core.$strict>;
+        disabledByApplication: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+            publicWebsite: "publicWebsite";
+            authenticatedWebsite: "authenticatedWebsite";
+            publicMessaging: "publicMessaging";
+        }>>>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export declare const ApplicationHistorySettingsResponseSchema: z.ZodObject<{
+    ok: z.ZodLiteral<true>;
+    data: z.ZodObject<{
+        revision: z.ZodString;
+        canEdit: z.ZodBoolean;
+        activity: z.ZodObject<{
+            retentionDays: z.ZodNumber;
+            maximumDays: z.ZodNumber;
+            defaultDays: z.ZodNumber;
+        }, z.core.$strict>;
+        conversations: z.ZodObject<{
+            state: z.ZodEnum<{
+                not_enabled: "not_enabled";
+                off: "off";
+                on: "on";
+            }>;
+            retentionDays: z.ZodOptional<z.ZodNumber>;
+            sources: z.ZodObject<{
+                websiteVisitors: z.ZodBoolean;
+                signedInCustomers: z.ZodBoolean;
+                whatsapp: z.ZodBoolean;
+            }, z.core.$strict>;
+            disabledByApplication: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+                publicWebsite: "publicWebsite";
+                authenticatedWebsite: "authenticatedWebsite";
+                publicMessaging: "publicMessaging";
+            }>>>;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+/** Omitted fields keep their value; `dryRun` reports the effect without saving. */
+export declare const ApplicationHistorySettingsSaveRequestSchema: z.ZodObject<{
+    expectedRevision: z.ZodString;
+    activityDays: z.ZodOptional<z.ZodNumber>;
+    conversations: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+        retentionDays: z.ZodNumber;
+    }, z.core.$strict>, z.ZodLiteral<"off">]>>;
+    sources: z.ZodOptional<z.ZodObject<{
+        websiteVisitors: z.ZodOptional<z.ZodBoolean>;
+        signedInCustomers: z.ZodOptional<z.ZodBoolean>;
+        whatsapp: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strict>>;
+    dryRun: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>;
+export declare const ApplicationHistorySettingsSaveResponseSchema: z.ZodObject<{
+    ok: z.ZodLiteral<true>;
+    data: z.ZodObject<{
+        dryRun: z.ZodBoolean;
+        shortensConversations: z.ZodBoolean;
+        impact: z.ZodObject<{
+            conversations: z.ZodNumber;
+            items: z.ZodNumber;
+        }, z.core.$strict>;
+        settings: z.ZodObject<{
+            revision: z.ZodString;
+            canEdit: z.ZodBoolean;
+            activity: z.ZodObject<{
+                retentionDays: z.ZodNumber;
+                maximumDays: z.ZodNumber;
+                defaultDays: z.ZodNumber;
+            }, z.core.$strict>;
+            conversations: z.ZodObject<{
+                state: z.ZodEnum<{
+                    not_enabled: "not_enabled";
+                    off: "off";
+                    on: "on";
+                }>;
+                retentionDays: z.ZodOptional<z.ZodNumber>;
+                sources: z.ZodObject<{
+                    websiteVisitors: z.ZodBoolean;
+                    signedInCustomers: z.ZodBoolean;
+                    whatsapp: z.ZodBoolean;
+                }, z.core.$strict>;
+                disabledByApplication: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+                    publicWebsite: "publicWebsite";
+                    authenticatedWebsite: "authenticatedWebsite";
+                    publicMessaging: "publicMessaging";
+                }>>>;
+            }, z.core.$strict>;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export declare const ApplicationHistorySettingsClientResponseSchema: z.ZodObject<{
+    ok: z.ZodLiteral<true>;
+    data: z.ZodObject<{
+        activity: z.ZodObject<{
+            retentionDays: z.ZodNumber;
+            maximumDays: z.ZodNumber;
+            defaultDays: z.ZodNumber;
+        }, z.core.$strip>;
+        conversations: z.ZodObject<{
+            sources: z.ZodObject<{
+                websiteVisitors: z.ZodBoolean;
+                signedInCustomers: z.ZodBoolean;
+                whatsapp: z.ZodBoolean;
+            }, z.core.$strip>;
+            state: z.ZodEnum<{
+                not_enabled: "not_enabled";
+                off: "off";
+                on: "on";
+            }>;
+            retentionDays: z.ZodOptional<z.ZodNumber>;
+            disabledByApplication: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+                publicWebsite: "publicWebsite";
+                authenticatedWebsite: "authenticatedWebsite";
+                publicMessaging: "publicMessaging";
+            }>>>;
+        }, z.core.$strip>;
+        revision: z.ZodString;
+        canEdit: z.ZodBoolean;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const ApplicationHistorySettingsSaveClientResponseSchema: z.ZodObject<{
+    ok: z.ZodLiteral<true>;
+    data: z.ZodObject<{
+        impact: z.ZodObject<{
+            conversations: z.ZodNumber;
+            items: z.ZodNumber;
+        }, z.core.$strip>;
+        settings: z.ZodObject<{
+            activity: z.ZodObject<{
+                retentionDays: z.ZodNumber;
+                maximumDays: z.ZodNumber;
+                defaultDays: z.ZodNumber;
+            }, z.core.$strip>;
+            conversations: z.ZodObject<{
+                sources: z.ZodObject<{
+                    websiteVisitors: z.ZodBoolean;
+                    signedInCustomers: z.ZodBoolean;
+                    whatsapp: z.ZodBoolean;
+                }, z.core.$strip>;
+                state: z.ZodEnum<{
+                    not_enabled: "not_enabled";
+                    off: "off";
+                    on: "on";
+                }>;
+                retentionDays: z.ZodOptional<z.ZodNumber>;
+                disabledByApplication: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+                    publicWebsite: "publicWebsite";
+                    authenticatedWebsite: "authenticatedWebsite";
+                    publicMessaging: "publicMessaging";
+                }>>>;
+            }, z.core.$strip>;
+            revision: z.ZodString;
+            canEdit: z.ZodBoolean;
+        }, z.core.$strip>;
+        dryRun: z.ZodBoolean;
+        shortensConversations: z.ZodBoolean;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+//# sourceMappingURL=application-history-settings.d.ts.map

package/node_modules/@noodle-borg/wire-contracts/dist/application-history-settings.js

@@ -0,0 +1,92 @@
+import { z } from 'zod';
+/**
+ * One installation history setting (ADR 0241 decision 6): an Activity duration and a conversation
+ * duration (which may be Off) under the plan cap, plus per-channel recording switches, sharing one
+ * revision. Server output is strict; the `*ClientResponseSchema` variants tolerate additive fields.
+ */
+const DaysSchema = z.number().int().min(1).max(365);
+const RevisionSchema = z.string().regex(/^[a-f0-9]{64}$/);
+const CountSchema = z.number().int().nonnegative();
+export const HistorySourcesSchema = z.strictObject({
+    websiteVisitors: z.boolean(),
+    signedInCustomers: z.boolean(),
+    whatsapp: z.boolean(),
+});
+/** A surface the application declared `history: false` on, named by its authoring constructor. */
+export const ApplicationHistoryDisabledSurfaceSchema = z.enum([
+    'publicWebsite',
+    'authenticatedWebsite',
+    'publicMessaging',
+]);
+export const ApplicationHistorySettingsSchema = z.strictObject({
+    revision: RevisionSchema,
+    canEdit: z.boolean(),
+    activity: z.strictObject({
+        retentionDays: DaysSchema,
+        maximumDays: DaysSchema,
+        defaultDays: DaysSchema,
+    }),
+    /** `not_enabled`: never opted in, so nothing is recorded; `off`: an Owner/Admin turned it off. */
+    conversations: z.strictObject({
+        state: z.enum(['not_enabled', 'off', 'on']),
+        retentionDays: DaysSchema.optional(),
+        sources: HistorySourcesSchema,
+        /**
+         * Surfaces whose chats are never kept, whatever this setting says, because the application
+         * declared `history: false` in server.ts (ADR 0241 decision 11). Absent when none do.
+         */
+        disabledByApplication: z.array(ApplicationHistoryDisabledSurfaceSchema).min(1).optional(),
+    }),
+});
+export const ApplicationHistorySettingsResponseSchema = z.strictObject({
+    ok: z.literal(true),
+    data: ApplicationHistorySettingsSchema,
+});
+/** Omitted fields keep their value; `dryRun` reports the effect without saving. */
+export const ApplicationHistorySettingsSaveRequestSchema = z
+    .strictObject({
+    expectedRevision: RevisionSchema,
+    activityDays: DaysSchema.optional(),
+    conversations: z
+        .union([z.strictObject({ retentionDays: DaysSchema }), z.literal('off')])
+        .optional(),
+    sources: HistorySourcesSchema.partial().optional(),
+    dryRun: z.boolean().optional(),
+})
+    .refine((value) => value.activityDays !== undefined ||
+    value.conversations !== undefined ||
+    value.sources !== undefined, { message: 'Change at least one history setting.' });
+/** Existing conversation history older than the proposed conversation window. */
+const HistoryImpactSchema = z.strictObject({ conversations: CountSchema, items: CountSchema });
+export const ApplicationHistorySettingsSaveResponseSchema = z.strictObject({
+    ok: z.literal(true),
+    data: z.strictObject({
+        dryRun: z.boolean(),
+        /** Whether the change shortens or turns off conversation history, which needs confirmation. */
+        shortensConversations: z.boolean(),
+        impact: HistoryImpactSchema,
+        /** The saved setting, or the unchanged current one for a dry run. */
+        settings: ApplicationHistorySettingsSchema,
+    }),
+});
+const ClientSettingsSchema = z.object({
+    ...ApplicationHistorySettingsSchema.shape,
+    activity: z.object(ApplicationHistorySettingsSchema.shape.activity.shape),
+    conversations: z.object({
+        ...ApplicationHistorySettingsSchema.shape.conversations.shape,
+        sources: z.object(HistorySourcesSchema.shape),
+    }),
+});
+export const ApplicationHistorySettingsClientResponseSchema = z.object({
+    ok: z.literal(true),
+    data: ClientSettingsSchema,
+});
+export const ApplicationHistorySettingsSaveClientResponseSchema = z.object({
+    ok: z.literal(true),
+    data: z.object({
+        ...ApplicationHistorySettingsSaveResponseSchema.shape.data.shape,
+        impact: z.object(HistoryImpactSchema.shape),
+        settings: ClientSettingsSchema,
+    }),
+});
+//# sourceMappingURL=application-history-settings.js.map