@unson/brainbase-mcp 0.21.1 → 0.22.0

package/dist/local-web-fetch-bridge.js

@@ -5,7 +5,7 @@ import { readBoundedBody } from './local-web-security.js';
  * read are forwarded; the Host, Origin and token were already checked on the
  * Node request, which stays the security boundary.
  */
-const FORWARDED_HEADERS = ['accept', 'content-type', 'if-match'];
+const FORWARDED_HEADERS = ['accept', 'content-type', 'if-match', 'idempotency-key'];
 export async function nodeRequestToFetch(request, options) {
     const method = (request.method ?? 'GET').toUpperCase();
     const headers = new Headers();

package/dist/local-web-host.d.ts

@@ -1,6 +1,11 @@
 import { type IncomingMessage, type Server, type ServerResponse } from 'node:http';
 import { type ObjectiveDefinitionBuilder } from './foundation-http.js';
 import { JudgmentValueProofJournalCache } from './judgment-value-proof-review.js';
+import { type MeetingMinutesLineageCorrectionHook } from './meeting-minutes-lineage-lifecycle.js';
+import type { MinutesLineageActor, MinutesLineageStore } from './meeting-minutes-lineage.js';
+import { type MeetingMinutesStore } from './meeting-minutes.js';
+import { type FilesystemMeetingMinutesAdapterOptions } from './meeting-minutes-storage.js';
+import { MeetingMinutesStorageController, type MeetingMinutesExternalSourceRegistry } from './meeting-minutes-storage-controller.js';
 /**
  * General local single-owner Web host (`brainbase web:serve`).
  *
@@ -19,6 +24,7 @@ export declare const LOCAL_WEB_DEFAULT_OWNER_ID = "self";
 export declare const LOCAL_WEB_STATUS_PATH = "/api/local/status";
 export declare const LOCAL_WEB_WORLD_MODEL_PREFIX = "/api/world-model";
 export declare const LOCAL_WEB_GRAPH_PREFIX = "/api/graph";
+export declare const LOCAL_WEB_MEETING_MINUTES_PREFIX = "/api/meeting-minutes";
 /**
  * An Objective is a few KB of text and criteria.  64 KiB leaves room for long
  * Japanese text (about 20k characters) while keeping a loopback request that
@@ -41,6 +47,27 @@ export interface LocalWebModuleContext {
     readonly now: () => Date;
     /** The host's one listing cache for the judgment journal, shared by every screen that reads it. */
     readonly journalCache: JudgmentValueProofJournalCache;
+    /** The one host-owned native meeting-minutes service shared by modules/extensions. */
+    readonly meetingMinutesStore: MeetingMinutesStore;
+    /** Explicitly configured storage runtime. Native minutes remain the default. */
+    readonly meetingMinutesStorage?: LocalWebMeetingMinutesStorageRuntime;
+    /** Explicitly configured lineage runtime. No lineage provider is guessed. */
+    readonly meetingMinutesLineage?: LocalWebMeetingMinutesLineageRuntime;
+}
+export interface LocalWebMeetingMinutesStorageRuntime {
+    readonly defaultExternal?: Readonly<{
+        provider: string;
+        locator: string;
+    }>;
+    readonly controller: MeetingMinutesStorageController;
+}
+export interface LocalWebMeetingMinutesLineageRuntime {
+    readonly store: MinutesLineageStore;
+    /** Host-owned actor. Browser actor fields are never used as authority. */
+    readonly actor: MinutesLineageActor;
+    readonly correctionHook: MeetingMinutesLineageCorrectionHook;
+    readonly correctionReason: string;
+    readonly candidateDefaults?: Readonly<Record<string, unknown>>;
 }
 /**
  * Server side of one screen.  The host has already rejected a non-loopback
@@ -75,8 +102,38 @@ export interface LocalWebHostOptions {
     /** Directory containing the packaged `ui/` files. */
     readonly uiDir?: string;
     readonly now?: () => Date;
+    /** Optional composition seam for organization adapters and lineage. */
+    readonly meetingMinutesStore?: MeetingMinutesStore;
+    /**
+     * Enables the storage controller only when a host supplies an explicit
+     * filesystem root and authorization policy. Browser input never supplies
+     * either value.
+     */
+    readonly meetingMinutesStorage?: LocalWebMeetingMinutesStorageOptions;
+    /** Enables lineage only with an organization supplied, real provider store. */
+    readonly meetingMinutesLineage?: LocalWebMeetingMinutesLineageOptions;
     readonly extensions?: readonly LocalWebExtension[];
 }
+export interface LocalWebMeetingMinutesStorageOptions {
+    readonly filesystem: Pick<FilesystemMeetingMinutesAdapterOptions, 'root' | 'authorize' | 'provider' | 'max_bytes'>;
+    readonly externalRegistry?: MeetingMinutesExternalSourceRegistry;
+    /** Optional host-selected external source used by the shared UI placement selector. */
+    readonly defaultExternal?: Readonly<{
+        provider: string;
+        locator: string;
+    }>;
+}
+export interface LocalWebMeetingMinutesLineageOptions {
+    /** The actual provider-backed ledger shared by the host. */
+    readonly store: MinutesLineageStore;
+    /** Optional host-selected actor; defaults to the local single-owner actor. */
+    readonly actor?: MinutesLineageActor;
+    /** Optional hook seam for organizations; default writes to the supplied store. */
+    readonly correctionHook?: MeetingMinutesLineageCorrectionHook;
+    readonly correctionReason?: string;
+    /** Non-authoritative UI defaults for the candidate form. */
+    readonly candidateDefaults?: Readonly<Record<string, unknown>>;
+}
 /** One organization term that names a field value, e.g. project.kind = product → プロダクト. */
 export interface GraphVocabularyTerm {
     readonly id: string;
@@ -97,6 +154,8 @@ export declare function isTrustedLocalWrite(request: IncomingMessage, token: str
 export declare function readLocalGraphState(dataDir: string): Promise<LocalGraphState>;
 export declare function createLocalStatusModule(context: LocalWebModuleContext): LocalWebModule;
 export declare function createValueProofModule(context: LocalWebModuleContext): LocalWebModule;
+/** Native meeting minutes use the host's authenticated local single-owner principal. */
+export declare function createMeetingMinutesModule(context: LocalWebModuleContext): LocalWebModule;
 /**
  * Trusted authority fields for a single owner.  The owner writes through the
  * launch-token browser session, so a new Objective is private to the owner,

package/dist/local-web-host.js

@@ -9,6 +9,13 @@ import { createFoundationHttpRouter, createObjectiveFoundationRoute, FOUNDATION_
 import { createFoundationRevisionStore, FoundationStoreError } from './foundation-store.js';
 import { createGraphWebHttpHandler } from './graph-web-http.js';
 import { defaultJudgmentJournalRoot, JudgmentValueProofJournalCache } from './judgment-value-proof-review.js';
+import { createMeetingMinutesHttpHandler } from './meeting-minutes-http.js';
+import { createMeetingMinutesLineageHttpHandler } from './meeting-minutes-lineage-http.js';
+import { createMeetingMinutesLineageCorrectionHook, } from './meeting-minutes-lineage-lifecycle.js';
+import { createMeetingMinutesStore } from './meeting-minutes.js';
+import { createFilesystemMeetingMinutesAdapter, } from './meeting-minutes-storage.js';
+import { MeetingMinutesStorageController, } from './meeting-minutes-storage-controller.js';
+import { createMeetingMinutesStorageHttpHandler } from './meeting-minutes-storage-http.js';
 import { nodeRequestToFetch, writeFetchResponse } from './local-web-fetch-bridge.js';
 import { assertSameOrigin, isLoopbackHost, LOCAL_WEB_CONTENT_SECURITY_POLICY, LocalWebHttpError, readJsonObjectBody, requestUrl, tokenMatches, writeHttpError, writeJson } from './local-web-security.js';
 import { resolveDataDir } from './paths.js';
@@ -33,6 +40,7 @@ export const LOCAL_WEB_DEFAULT_OWNER_ID = 'self';
 export const LOCAL_WEB_STATUS_PATH = '/api/local/status';
 export const LOCAL_WEB_WORLD_MODEL_PREFIX = '/api/world-model';
 export const LOCAL_WEB_GRAPH_PREFIX = '/api/graph';
+export const LOCAL_WEB_MEETING_MINUTES_PREFIX = '/api/meeting-minutes';
 /**
  * An Objective is a few KB of text and criteria.  64 KiB leaves room for long
  * Japanese text (about 20k characters) while keeping a loopback request that
@@ -171,6 +179,147 @@ export function createValueProofModule(context) {
         handle: handler
     };
 }
+/** Native meeting minutes use the host's authenticated local single-owner principal. */
+export function createMeetingMinutesModule(context) {
+    const lineage = context.meetingMinutesLineage;
+    const afterSave = lineage
+        ? async ({ before, after, context: saveContext }) => {
+            const pair = savedLineageVersionPair(before, after);
+            if (!pair)
+                return undefined;
+            return lineage.correctionHook.onVersionSaved({
+                previousVersion: pair.previousVersion,
+                replacementVersion: pair.replacementVersion,
+                access: { principal: saveContext.principal_id },
+                actor: lineage.actor,
+                reason: lineage.correctionReason,
+            });
+        }
+        : undefined;
+    const handler = context.meetingMinutesStorage
+        ? createMeetingMinutesStorageHttpHandler({
+            store: context.meetingMinutesStore,
+            controller: context.meetingMinutesStorage.controller,
+            basePath: LOCAL_WEB_MEETING_MINUTES_PREFIX,
+            resolveContext: () => ({ principal_id: LOCAL_WEB_DEFAULT_OWNER_ID }),
+            ...(afterSave ? { afterSave } : {}),
+        })
+        : createMeetingMinutesHttpHandler({
+            store: context.meetingMinutesStore,
+            basePath: LOCAL_WEB_MEETING_MINUTES_PREFIX,
+            resolveContext: () => ({ principal_id: LOCAL_WEB_DEFAULT_OWNER_ID }),
+            ...(afterSave ? { afterSave } : {}),
+        });
+    const lineageHandler = lineage
+        ? createMeetingMinutesLineageHttpHandler({
+            store: lineage.store,
+            basePath: '/api/meeting-minutes-lineage',
+            resolveAccess: () => ({ principal: LOCAL_WEB_DEFAULT_OWNER_ID }),
+            resolveActor: () => lineage.actor,
+            assertWriteAllowed: (request) => {
+                const rejected = rejectUntrustedWrite(request, context.token);
+                if (rejected)
+                    throw rejected;
+            },
+        })
+        : undefined;
+    return {
+        id: 'meeting-minutes',
+        uiFiles: [
+            'meeting-minutes.js',
+            'meeting-minutes.css',
+            'meeting-minutes-storage.js',
+            'meeting-minutes-storage.css',
+            'meeting-minutes-lineage.js',
+            'meeting-minutes-lineage.css',
+            'meeting-minutes-lineage-http.js',
+        ],
+        async handle(request, response) {
+            if (await handler(request, response))
+                return true;
+            return lineageHandler ? lineageHandler(request, response) : false;
+        }
+    };
+}
+function savedLineageVersionPair(before, after) {
+    for (const beforeDocument of before.minutes) {
+        const afterDocument = after.minutes.find((candidate) => candidate.minutes_id === beforeDocument.minutes_id);
+        if (!afterDocument || afterDocument.current_version_id === beforeDocument.current_version_id)
+            continue;
+        const previous = before.versions.find((candidate) => candidate.version_id === beforeDocument.current_version_id);
+        const replacement = after.versions.find((candidate) => candidate.version_id === afterDocument.current_version_id);
+        if (!previous || !replacement)
+            continue;
+        return {
+            previousVersion: nativeLineageVersion(previous),
+            replacementVersion: nativeLineageVersion(replacement),
+        };
+    }
+    return undefined;
+}
+function nativeLineageVersion(version) {
+    return {
+        version_id: version.version_id,
+        minutes_id: version.minutes_id,
+        meeting_id: version.meeting_id,
+        ...(version.predecessor_version_id ? { predecessor_version_id: version.predecessor_version_id } : {}),
+        ...(version.body_digest ? { body_digest: version.body_digest } : {}),
+        ...(version.source_ref ? { source_ref: version.source_ref } : {}),
+    };
+}
+function createLocalWebMeetingMinutesStorageRuntime(options, core) {
+    if (!options.filesystem || typeof options.filesystem !== 'object') {
+        throw new TypeError('meetingMinutesStorage.filesystem is required');
+    }
+    const provider = typeof options.filesystem.provider === 'string' && options.filesystem.provider.trim()
+        ? options.filesystem.provider.trim()
+        : 'filesystem';
+    const adapter = createFilesystemMeetingMinutesAdapter({ ...options.filesystem, provider });
+    const defaultExternal = options.defaultExternal;
+    if (defaultExternal !== undefined) {
+        if (typeof defaultExternal.provider !== 'string' || !defaultExternal.provider.trim()
+            || typeof defaultExternal.locator !== 'string' || !defaultExternal.locator.trim()) {
+            throw new TypeError('meetingMinutesStorage.defaultExternal provider and locator are required');
+        }
+        if (defaultExternal.provider.trim() !== provider) {
+            throw new TypeError('meetingMinutesStorage.defaultExternal provider must match the configured filesystem provider');
+        }
+    }
+    return {
+        controller: new MeetingMinutesStorageController({
+            core,
+            external_adapters: [{ provider, adapter }],
+            external_registry: options.externalRegistry,
+        }),
+        ...(defaultExternal
+            ? { defaultExternal: Object.freeze({ provider: defaultExternal.provider.trim(), locator: defaultExternal.locator.trim() }) }
+            : {}),
+    };
+}
+function createLocalWebMeetingMinutesLineageRuntime(options) {
+    if (!options.store || typeof options.store.readByMinutesVersion !== 'function'
+        || typeof options.store.createCandidate !== 'function'
+        || typeof options.store.markCorrection !== 'function') {
+        throw new TypeError('meetingMinutesLineage.store must be a complete lineage store');
+    }
+    const actor = options.actor ?? { type: 'person', id: LOCAL_WEB_DEFAULT_OWNER_ID };
+    if (!actor || !['person', 'agent', 'service', 'system'].includes(actor.type)
+        || typeof actor.id !== 'string' || actor.id.trim() === '') {
+        throw new TypeError('meetingMinutesLineage.actor must be a trusted actor');
+    }
+    const correctionReason = options.correctionReason?.trim() || '議事録版を修正しました';
+    const correctionHook = options.correctionHook ?? createMeetingMinutesLineageCorrectionHook({ store: options.store });
+    if (!correctionHook || typeof correctionHook.onVersionSaved !== 'function') {
+        throw new TypeError('meetingMinutesLineage.correctionHook must implement onVersionSaved');
+    }
+    return {
+        store: options.store,
+        actor: { type: actor.type, id: actor.id.trim() },
+        correctionHook,
+        correctionReason,
+        ...(options.candidateDefaults ? { candidateDefaults: options.candidateDefaults } : {}),
+    };
+}
 const NOTHING_UNREADABLE = Object.freeze({ count: 0, codes: [] });
 function isFoundationDenial(error) {
     return error instanceof FoundationStoreError && (error.code === 'authorization_denied' || error.code === 'scope_violation');
@@ -709,6 +858,7 @@ export function defaultLocalWebModules(context) {
     return [
         createLocalStatusModule(context),
         createValueProofModule(context),
+        createMeetingMinutesModule(context),
         createObjectiveFoundationModule(context),
         createWorldModelReadModule(context),
         createGraphWebModule(context)
@@ -734,7 +884,7 @@ ${stylesheets.map((path) => `<link rel="stylesheet" href="${escapeAttribute(path
 </html>
 `;
 }
-function bootstrapJs(extensions) {
+function bootstrapJs(extensions, meetingMinutesStorage, meetingMinutesLineage) {
     const imports = extensions.map((extension, index) => `import { screen as extensionScreen${index} } from '/ui/extensions/${extension.id}/${extension.screenEntry}';`).join('\n');
     const leading = extensions.flatMap((extension, index) => (extension.navPosition === 'first' ? [`extensionScreen${index}`] : [])).join(', ');
     const trailing = extensions.flatMap((extension, index) => (extension.navPosition === 'first' ? [] : [`extensionScreen${index}`])).join(', ');
@@ -755,6 +905,8 @@ const shell = createLocalWebShell({
   root: document.getElementById('brainbase-local-web'),
   token: meta('brainbase-web-token'),
   initialScreen: screenFromHash(),
+  meetingMinutesStorage: ${JSON.stringify(meetingMinutesStorage ?? null)},
+  meetingMinutesLineage: ${JSON.stringify(meetingMinutesLineage ?? null)},
   screens: ${leading ? `[${leading}, ...LOCAL_WEB_SCREENS${trailing ? `, ${trailing}` : ''}]` : '[...LOCAL_WEB_SCREENS, ...extensionScreens]'}
 });
 addEventListener('hashchange', () => shell.show(screenFromHash()));
@@ -771,12 +923,23 @@ export function createLocalWebHost(options = {}) {
     const dataDir = resolveDataDir(options.dataDir);
     const journalRoot = options.journalRoot ?? defaultJudgmentJournalRoot(dataDir);
     const uiDir = options.uiDir ?? fileURLToPath(new URL('../ui/', import.meta.url));
+    const now = options.now ?? (() => new Date());
+    const meetingMinutesStore = options.meetingMinutesStore ?? createMeetingMinutesStore({ data_dir: dataDir, now });
+    const meetingMinutesStorage = options.meetingMinutesStorage
+        ? createLocalWebMeetingMinutesStorageRuntime(options.meetingMinutesStorage, meetingMinutesStore)
+        : undefined;
+    const meetingMinutesLineage = options.meetingMinutesLineage
+        ? createLocalWebMeetingMinutesLineageRuntime(options.meetingMinutesLineage)
+        : undefined;
     const context = {
         dataDir,
         journalRoot,
         token,
-        now: options.now ?? (() => new Date()),
-        journalCache: new JudgmentValueProofJournalCache()
+        now,
+        journalCache: new JudgmentValueProofJournalCache(),
+        meetingMinutesStore,
+        ...(meetingMinutesStorage ? { meetingMinutesStorage } : {}),
+        ...(meetingMinutesLineage ? { meetingMinutesLineage } : {})
     };
     const modules = defaultLocalWebModules(context);
     const extensions = [...options.extensions ?? []];
@@ -853,7 +1016,11 @@ export function createLocalWebHost(options = {}) {
         }
         if (path === '/app.js') {
             response.setHeader('Content-Type', 'text/javascript; charset=utf-8');
-            response.end(bootstrapJs(extensions));
+            response.end(bootstrapJs(extensions, meetingMinutesStorage
+                ? { defaultExternal: meetingMinutesStorage.defaultExternal }
+                : undefined, meetingMinutesLineage
+                ? { candidateDefaults: meetingMinutesLineage.candidateDefaults }
+                : undefined));
             return;
         }
         const asset = uiFiles.get(path);

package/dist/meeting-minutes-http.d.ts

@@ -0,0 +1,22 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import { type MeetingMinutesDetail, type MeetingMinutesRequestContext, type MeetingMinutesStore } from './meeting-minutes.js';
+/** HTTP contract shared by the local and organization meeting-minutes hosts. */
+export declare const MEETING_MINUTES_HTTP_VERSION: "brainbase.meeting-minutes-http.v1";
+export declare const MEETING_MINUTES_HTTP_PREFIX: "/api/meeting-minutes";
+type MaybePromise<T> = T | Promise<T>;
+export interface MeetingMinutesHttpOptions {
+    readonly store: MeetingMinutesStore;
+    /** The host supplies the trusted principal; request JSON is never used. */
+    readonly resolveContext: (request: IncomingMessage) => MaybePromise<MeetingMinutesRequestContext>;
+    /** Called only after a save has returned the core's readback detail. */
+    readonly afterSave?: (input: {
+        readonly before: MeetingMinutesDetail;
+        readonly after: MeetingMinutesDetail;
+        readonly context: MeetingMinutesRequestContext;
+    }) => MaybePromise<unknown>;
+    readonly basePath?: string;
+    readonly bodyLimitBytes?: number;
+}
+export type MeetingMinutesHttpHandler = (request: IncomingMessage, response: ServerResponse) => Promise<boolean>;
+export declare function createMeetingMinutesHttpHandler(options: MeetingMinutesHttpOptions): MeetingMinutesHttpHandler;
+export {};

package/dist/meeting-minutes-http.js

@@ -0,0 +1,252 @@
+import { createHash } from 'node:crypto';
+import { MeetingMinutesError } from './meeting-minutes.js';
+import { LocalWebHttpError, readJsonObjectBody, requestUrl, writeHttpError, writeJson } from './local-web-security.js';
+/** HTTP contract shared by the local and organization meeting-minutes hosts. */
+export const MEETING_MINUTES_HTTP_VERSION = 'brainbase.meeting-minutes-http.v1';
+export const MEETING_MINUTES_HTTP_PREFIX = '/api/meeting-minutes';
+const DEFAULT_BODY_LIMIT_BYTES = 1024 * 1024;
+const MAX_IDEMPOTENCY_KEY_LENGTH = 200;
+function normalizeBasePath(path) {
+    const value = (path ?? MEETING_MINUTES_HTTP_PREFIX).trim().replace(/\/+$/u, '');
+    if (!value.startsWith('/') || value === '')
+        throw new TypeError('basePath must be an absolute path');
+    return value;
+}
+function decodePathSegment(value) {
+    try {
+        const decoded = decodeURIComponent(value);
+        return decoded === '' || decoded.includes('/') ? undefined : decoded;
+    }
+    catch {
+        return undefined;
+    }
+}
+function routeFor(pathname, basePath) {
+    if (pathname === basePath)
+        return { kind: 'collection' };
+    if (!pathname.startsWith(`${basePath}/`))
+        return undefined;
+    const rawSegments = pathname.slice(basePath.length + 1).split('/');
+    if (rawSegments.some((segment) => segment === ''))
+        return { kind: 'meeting' };
+    const segments = rawSegments.map(decodePathSegment);
+    if (segments.some((segment) => segment === undefined))
+        return { kind: 'meeting' };
+    const [meetingId, noun, minutesId, action, versionId] = segments;
+    if (!meetingId)
+        return { kind: 'meeting' };
+    if (segments.length === 1)
+        return { kind: 'meeting', meetingId };
+    if (segments.length === 2 && noun === 'minutes')
+        return { kind: 'minutes', meetingId };
+    if (segments.length === 3 && noun === 'minutes' && minutesId)
+        return { kind: 'save', meetingId, minutesId };
+    if (segments.length === 4 && noun === 'minutes' && minutesId && action === 'confirm') {
+        return { kind: 'confirm', meetingId, minutesId };
+    }
+    if (segments.length === 5 && noun === 'minutes' && minutesId && action === 'versions' && versionId) {
+        return { kind: 'version', meetingId, minutesId, versionId };
+    }
+    return { kind: 'meeting' };
+}
+function canonicalJson(value) {
+    if (value === null || typeof value !== 'object')
+        return JSON.stringify(value);
+    if (Array.isArray(value))
+        return `[${value.map(canonicalJson).join(',')}]`;
+    const entries = Object.entries(value)
+        .sort(([left], [right]) => left.localeCompare(right))
+        .map(([key, child]) => `${JSON.stringify(key)}:${canonicalJson(child)}`);
+    return `{${entries.join(',')}}`;
+}
+function headerValue(request, name) {
+    const value = request.headers[name.toLowerCase()];
+    return typeof value === 'string' ? value : undefined;
+}
+function idempotencyKey(request) {
+    const value = headerValue(request, 'idempotency-key');
+    if (value === undefined)
+        return undefined;
+    const key = value.trim();
+    if (key === '' || key.length > MAX_IDEMPOTENCY_KEY_LENGTH) {
+        throw new LocalWebHttpError(422, 'invalid_idempotency_key', 'Idempotency-Key must be 1–200 characters');
+    }
+    return key;
+}
+function requestFingerprint(value) {
+    return `sha256:${createHash('sha256').update(canonicalJson(value), 'utf8').digest('hex')}`;
+}
+function idempotencyFields(key, fingerprint) {
+    if (key === undefined || fingerprint === undefined)
+        return {};
+    return { idempotency_key: key, idempotency_fingerprint: fingerprint };
+}
+function statusForDomainError(error) {
+    switch (error.code) {
+        case 'invalid_input': return 422;
+        case 'not_found': return 404;
+        case 'revision_conflict':
+        case 'idempotency_conflict': return 409;
+        case 'authorization_denied': return 403;
+        case 'corrupt_record':
+        case 'storage_unavailable':
+        case 'readback_mismatch': return 500;
+    }
+}
+function publicDomainMessage(error) {
+    if (error.code === 'corrupt_record')
+        return 'Meeting minutes storage contains an invalid record';
+    if (error.code === 'storage_unavailable')
+        return 'Meeting minutes storage is unavailable';
+    if (error.code === 'readback_mismatch')
+        return 'Meeting minutes storage did not confirm the saved record';
+    return error.message;
+}
+function operationError(error) {
+    if (error instanceof MeetingMinutesError) {
+        return {
+            statusCode: statusForDomainError(error),
+            body: { error: { code: error.code, message: publicDomainMessage(error) } }
+        };
+    }
+    return { statusCode: 500, body: { error: { code: 'internal_error', message: 'Meeting minutes request failed' } } };
+}
+function hasOwn(body, key) {
+    return Object.prototype.hasOwnProperty.call(body, key);
+}
+function createInput(body, key, fingerprint) {
+    return {
+        title: body.title,
+        scheduled_at: body.scheduled_at,
+        ended_at: body.ended_at,
+        participant_ids: body.participant_ids,
+        metadata: body.metadata,
+        minutes_title: body.minutes_title,
+        minutes_metadata: body.minutes_metadata,
+        initial_body: body.initial_body,
+        source_ref: body.source_ref,
+        ...idempotencyFields(key, fingerprint)
+    };
+}
+function createMinutesInput(body, key, fingerprint) {
+    return {
+        title: body.title,
+        metadata: body.metadata,
+        ...(hasOwn(body, 'body') ? { body: body.body } : {}),
+        ...(hasOwn(body, 'source_ref') ? { source_ref: body.source_ref } : {}),
+        expected_revision: body.expected_revision,
+        ...idempotencyFields(key, fingerprint)
+    };
+}
+function saveInput(body, minutesId, key, fingerprint) {
+    return {
+        minutes_id: minutesId ?? body.minutes_id,
+        ...(hasOwn(body, 'body') ? { body: body.body } : {}),
+        ...(hasOwn(body, 'source_ref') ? { source_ref: body.source_ref } : {}),
+        metadata: body.metadata,
+        expected_revision: body.expected_revision,
+        predecessor_version_id: body.predecessor_version_id,
+        ...idempotencyFields(key, fingerprint)
+    };
+}
+function confirmInput(body, minutesId, key, fingerprint) {
+    return {
+        minutes_id: minutesId,
+        version_id: body.version_id,
+        expected_revision: body.expected_revision,
+        ...idempotencyFields(key, fingerprint)
+    };
+}
+export function createMeetingMinutesHttpHandler(options) {
+    if (!options || !options.store || typeof options.resolveContext !== 'function') {
+        throw new TypeError('store and resolveContext are required');
+    }
+    const basePath = normalizeBasePath(options.basePath);
+    const bodyLimitBytes = options.bodyLimitBytes ?? DEFAULT_BODY_LIMIT_BYTES;
+    if (!Number.isInteger(bodyLimitBytes) || bodyLimitBytes <= 0)
+        throw new TypeError('bodyLimitBytes must be a positive integer');
+    async function execute(route, body, context, key, fingerprint) {
+        try {
+            switch (route.kind) {
+                case 'collection':
+                    if (body === undefined)
+                        return { statusCode: 200, body: { state: 'ready', meetings: await options.store.list_meetings(context), absence_confirmed: true } };
+                    return { statusCode: 201, body: await options.store.create_meeting(createInput(body, key, fingerprint), context) };
+                case 'meeting':
+                    return { statusCode: 200, body: await options.store.get_meeting(route.meetingId ?? '', context) };
+                case 'minutes': {
+                    if (body === undefined)
+                        throw new MeetingMinutesError('invalid_input', 'Request body is required');
+                    return { statusCode: 201, body: await options.store.create_minutes(route.meetingId ?? '', createMinutesInput(body, key, fingerprint), context) };
+                }
+                case 'save': {
+                    if (body === undefined)
+                        throw new MeetingMinutesError('invalid_input', 'Request body is required');
+                    const before = await options.store.get_meeting(route.meetingId ?? '', context);
+                    if (!before.minutes.some((candidate) => candidate.minutes_id === route.minutesId)) {
+                        throw new MeetingMinutesError('not_found', `Minutes document ${route.minutesId} was not found`);
+                    }
+                    const after = await options.store.save_version(saveInput(body, route.minutesId, key, fingerprint), context);
+                    const lineage = options.afterSave ? await options.afterSave({ before, after, context }) : undefined;
+                    return { statusCode: 201, body: lineage === undefined ? after : { ...after, lineage } };
+                }
+                case 'confirm': {
+                    if (body === undefined)
+                        throw new MeetingMinutesError('invalid_input', 'Request body is required');
+                    const detail = await options.store.get_meeting(route.meetingId ?? '', context);
+                    const document = detail.minutes.find((candidate) => candidate.minutes_id === route.minutesId);
+                    if (!document)
+                        throw new MeetingMinutesError('not_found', `Minutes document ${route.minutesId} was not found`);
+                    if (!detail.versions.some((candidate) => candidate.version_id === body.version_id && candidate.minutes_id === route.minutesId)) {
+                        throw new MeetingMinutesError('not_found', `Minutes version ${String(body.version_id)} was not found`);
+                    }
+                    return { statusCode: 200, body: await options.store.confirm_version(confirmInput(body, document.minutes_id, key, fingerprint), context) };
+                }
+                case 'version':
+                    return {
+                        statusCode: 200,
+                        body: await options.store.get_version(route.meetingId ?? '', route.minutesId ?? '', route.versionId ?? '', context)
+                    };
+            }
+        }
+        catch (error) {
+            return operationError(error);
+        }
+    }
+    return async (request, response) => {
+        const path = requestUrl(request).pathname;
+        const route = routeFor(path, basePath);
+        if (!route)
+            return false;
+        const method = (request.method ?? 'GET').toUpperCase();
+        const allowed = route.kind === 'collection' ? ['GET', 'POST']
+            : route.kind === 'meeting' || route.kind === 'version' ? ['GET']
+                : ['POST'];
+        if (!allowed.includes(method)) {
+            response.setHeader('Allow', allowed.join(', '));
+            writeJson(response, 405, { error: { code: 'method_not_allowed', message: `Use ${allowed.join(' or ')}` } });
+            return true;
+        }
+        try {
+            const context = await options.resolveContext(request);
+            if (!context || typeof context.principal_id !== 'string' || context.principal_id.trim() === '') {
+                throw new LocalWebHttpError(401, 'authorization_required', 'A trusted meeting-minutes principal is required');
+            }
+            const body = method === 'POST' ? await readJsonObjectBody(request, bodyLimitBytes) : undefined;
+            const key = method === 'POST' ? idempotencyKey(request) : undefined;
+            const fingerprint = key === undefined ? undefined : requestFingerprint({ method, path, body: body ?? null });
+            // Idempotency is persisted by the domain store in the same CAS snapshot
+            // as the mutation.  Keeping no result cache here ensures retries after a
+            // restart, and retries after ACL changes, are reauthorized by the store.
+            const result = await execute(route, body, context, key, fingerprint);
+            writeJson(response, result.statusCode, result.body);
+        }
+        catch (error) {
+            if (error instanceof LocalWebHttpError)
+                writeHttpError(response, error);
+            else
+                writeJson(response, 500, { error: { code: 'internal_error', message: 'Meeting minutes request failed' } });
+        }
+        return true;
+    };
+}