@aopslab/domain-kit-docman 0.1.4

package/dist/operations/dcm.d.ts

@@ -0,0 +1,58 @@
+import type { DocmanOperationSideEffect } from './contract.js';
+import type { DocmanOperationPolicy } from './types.js';
+export type DocmanDomainCapabilityOperation = {
+    operationId: string;
+    title?: string;
+    sideEffect?: DocmanOperationSideEffect;
+    tags?: string[];
+    inputSchemaRef?: string;
+    outputSchemaRef?: string;
+};
+export type DocmanDomainCapabilityOperationDocs = {
+    summary?: string;
+    notes?: string[];
+    examples?: string[];
+    antiPatterns?: string[];
+    preconditions?: string[];
+    postconditions?: string[];
+};
+export type DocmanDomainCapabilityResource = {
+    resourceId: string;
+    title: string;
+    kind?: string;
+};
+export type DocmanDomainDiscoveryDocs = {
+    summary?: string;
+    notes?: string[];
+};
+export type DocmanDomainCapabilityManifest = {
+    manifestVersion: string;
+    domain: {
+        id: string;
+        version: string;
+        displayName?: string;
+        description?: string;
+    };
+    capabilities: {
+        operations: DocmanDomainCapabilityOperation[];
+        resources?: DocmanDomainCapabilityResource[];
+    };
+    contracts?: {
+        schemas: Record<string, unknown>;
+    };
+    policies?: {
+        operations: Record<string, DocmanOperationPolicy>;
+    };
+    docs?: {
+        domain?: DocmanDomainDiscoveryDocs;
+        resources?: Record<string, DocmanDomainDiscoveryDocs>;
+        operations?: Record<string, DocmanDomainCapabilityOperationDocs>;
+    };
+};
+export type BuildDocmanDomainCapabilityManifestOptions = {
+    manifestVersion?: string;
+    domainVersion?: string;
+    includeDocs?: boolean;
+    refresh?: boolean;
+};
+export declare function buildDocmanDomainCapabilityManifest(options?: BuildDocmanDomainCapabilityManifestOptions): DocmanDomainCapabilityManifest;

package/dist/operations/dcm.js

@@ -0,0 +1,168 @@
+import { listDocmanOperationContracts } from './contract.js';
+import { getDocmanContractSchema, resolveDocmanSchemaRefName } from './schemas.js';
+function toTags(operation) {
+    const tags = new Set();
+    for (const tag of operation.tags ?? []) {
+        const normalized = String(tag ?? '').trim();
+        if (!normalized)
+            continue;
+        tags.add(normalized);
+    }
+    tags.add(`kind:${operation.kind}`);
+    tags.add(`resource:${operation.serviceEntity}`);
+    tags.add(`service:${operation.serviceKey}`);
+    return [...tags];
+}
+function humanizeResource(resource) {
+    const label = resource
+        .replace(/^docman\./, '')
+        .replace(/[._-]+/g, ' ')
+        .replace(/\s+/g, ' ')
+        .trim();
+    if (!label)
+        return 'Resource';
+    return label.charAt(0).toUpperCase() + label.slice(1);
+}
+function inferResourceKind(resourceId) {
+    if (resourceId.includes('link'))
+        return 'relationship';
+    if (resourceId.includes('version'))
+        return 'versioned-record';
+    if (resourceId.includes('asset') || resourceId.includes('snippet') || resourceId.includes('embed'))
+        return 'content-asset';
+    return 'document-record';
+}
+function buildResourceSummary(resourceTitle, operationKinds) {
+    if (operationKinds.length === 0) {
+        return `${resourceTitle} records used to compose, version, and render documentation content.`;
+    }
+    if (operationKinds.length === 1) {
+        return `Supports ${operationKinds[0]} operations for ${resourceTitle.toLowerCase()} in documentation workflows.`;
+    }
+    return `Supports ${operationKinds.slice(0, 5).join(', ')} operations for ${resourceTitle.toLowerCase()} in documentation workflows.`;
+}
+function buildCapabilityResources(operations) {
+    const seen = new Map();
+    for (const operation of operations) {
+        const resourceId = String(operation.serviceEntity ?? '').trim();
+        if (!resourceId || seen.has(resourceId))
+            continue;
+        seen.set(resourceId, {
+            resourceId,
+            title: humanizeResource(resourceId),
+            kind: inferResourceKind(resourceId),
+        });
+    }
+    return [...seen.values()].sort((left, right) => left.title.localeCompare(right.title));
+}
+function buildResourceDocs(operations) {
+    const operationKindsByResource = new Map();
+    for (const operation of operations) {
+        const resourceId = String(operation.serviceEntity ?? '').trim();
+        if (!resourceId)
+            continue;
+        const existing = operationKindsByResource.get(resourceId) ?? new Set();
+        existing.add(operation.kind);
+        operationKindsByResource.set(resourceId, existing);
+    }
+    return Object.fromEntries([...operationKindsByResource.entries()]
+        .sort(([left], [right]) => humanizeResource(left).localeCompare(humanizeResource(right)))
+        .map(([resourceId, operationKinds]) => [
+        resourceId,
+        {
+            summary: buildResourceSummary(humanizeResource(resourceId), [...operationKinds]),
+        },
+    ]));
+}
+function toOperationDocs(operation) {
+    const requiredArgs = operation.args.filter((arg) => !arg.optional).map((arg) => arg.name);
+    const optionalArgs = operation.args.filter((arg) => arg.optional).map((arg) => arg.name);
+    const notes = [...(operation.notes ?? [])];
+    if (requiredArgs.length > 0)
+        notes.push(`required args: ${requiredArgs.join(', ')}`);
+    if (optionalArgs.length > 0)
+        notes.push(`optional args: ${optionalArgs.join(', ')}`);
+    return {
+        summary: operation.summary,
+        ...(notes.length > 0 ? { notes } : {}),
+        ...(operation.examples && operation.examples.length > 0 ? { examples: [...operation.examples] } : {}),
+        ...(operation.antiPatterns && operation.antiPatterns.length > 0 ? { antiPatterns: [...operation.antiPatterns] } : {}),
+        ...(operation.preconditions && operation.preconditions.length > 0 ? { preconditions: [...operation.preconditions] } : {}),
+        ...(operation.postconditions && operation.postconditions.length > 0 ? { postconditions: [...operation.postconditions] } : {}),
+    };
+}
+function toCapabilityOperation(operation) {
+    const inputSchemaRef = resolveDocmanSchemaRefName(operation.inputSchema);
+    const outputSchemaRef = resolveDocmanSchemaRefName(operation.outputSchema);
+    return {
+        operationId: operation.operationId,
+        title: operation.summary,
+        sideEffect: operation.sideEffect,
+        tags: toTags(operation),
+        ...(inputSchemaRef ? { inputSchemaRef } : {}),
+        ...(outputSchemaRef ? { outputSchemaRef } : {}),
+    };
+}
+export function buildDocmanDomainCapabilityManifest(options = {}) {
+    const operations = listDocmanOperationContracts({ refresh: options.refresh });
+    const manifest = {
+        manifestVersion: options.manifestVersion ?? '1.0.0',
+        domain: {
+            id: 'docman',
+            version: options.domainVersion ?? '0.0.0',
+            displayName: 'Docman',
+            description: 'Document composition and content-structure tooling for documents, sections, pages, snippets, assets, embeds, and version history.',
+        },
+        capabilities: {
+            operations: operations.map(toCapabilityOperation),
+            resources: buildCapabilityResources(operations),
+        },
+    };
+    if (options.includeDocs !== false) {
+        manifest.docs = {
+            domain: {
+                summary: 'Create, organize, version, render, and link documentation content across documents, sections, pages, snippets, assets, embeds, and structure links.',
+                notes: [
+                    'page-version.format accepts md and mdx as native source formats',
+                    'native compose/fetch accepts md and mdx source today',
+                    'publish materialize currently returns deterministic markdown or html text payloads',
+                    'publish target dispatch is registry-backed internally; future artifact exporters remain a separate contract track',
+                    'asset:// logical references in md/mdx source resolve through asset and asset-version ownership during compose',
+                    'asset and asset-version now provide the publish-grade ownership foundation for images and attached resources',
+                    'embed records remain the lightweight placement/render-hint layer that can later bind to asset ownership',
+                ],
+            },
+            resources: buildResourceDocs(operations),
+            operations: Object.fromEntries(operations.map((operation) => [operation.operationId, toOperationDocs(operation)])),
+        };
+    }
+    const operationPolicies = {};
+    for (const operation of operations) {
+        if (!operation.policy)
+            continue;
+        operationPolicies[operation.operationId] = operation.policy;
+    }
+    if (Object.keys(operationPolicies).length > 0) {
+        manifest.policies = { operations: operationPolicies };
+    }
+    const schemaRefs = new Set();
+    for (const operation of manifest.capabilities.operations) {
+        if (operation.inputSchemaRef)
+            schemaRefs.add(operation.inputSchemaRef);
+        if (operation.outputSchemaRef)
+            schemaRefs.add(operation.outputSchemaRef);
+    }
+    if (schemaRefs.size > 0) {
+        const schemas = {};
+        for (const ref of schemaRefs) {
+            const schema = getDocmanContractSchema(ref);
+            if (!schema)
+                continue;
+            schemas[ref] = schema;
+        }
+        if (Object.keys(schemas).length > 0) {
+            manifest.contracts = { schemas };
+        }
+    }
+    return manifest;
+}

package/dist/operations/definition.d.ts

@@ -0,0 +1,6 @@
+import type { DefineDocmanKitOperationInput, DocmanOperationSpec } from './types.js';
+export declare function normalizeDocmanOperationId(value: string): string;
+export declare function buildDocmanToolIdFromOperation(operationId: string): string;
+export declare function defineDocmanKitOperation(input: DefineDocmanKitOperationInput): DocmanOperationSpec;
+export declare function defineDocmanKitOperations(input: DefineDocmanKitOperationInput[]): DocmanOperationSpec[];
+export declare function cloneDocmanOperationSpec(spec: DocmanOperationSpec): DocmanOperationSpec;

package/dist/operations/definition.js

@@ -0,0 +1,140 @@
+const TOOL_PREFIX = 'docman-';
+function normalizeNonEmpty(value) {
+    return String(value ?? '').trim();
+}
+function normalizeTags(tags) {
+    if (!tags || tags.length === 0)
+        return undefined;
+    const unique = new Set();
+    for (const tag of tags) {
+        const normalized = String(tag ?? '').trim();
+        if (!normalized)
+            continue;
+        unique.add(normalized);
+    }
+    if (unique.size === 0)
+        return undefined;
+    return [...unique];
+}
+function cloneArgs(args) {
+    if (!args || args.length === 0)
+        return [];
+    return args.map((arg) => ({
+        name: String(arg.name ?? '').trim(),
+        optional: arg.optional === true,
+    }));
+}
+function normalizeExamples(examples) {
+    if (!examples || examples.length === 0)
+        return undefined;
+    const normalized = examples.map((example) => String(example ?? '').trim()).filter(Boolean);
+    if (normalized.length === 0)
+        return undefined;
+    return normalized;
+}
+function normalizeStringList(values) {
+    if (!values || values.length === 0)
+        return undefined;
+    const unique = new Set();
+    for (const value of values) {
+        const normalized = String(value ?? '').trim();
+        if (!normalized)
+            continue;
+        unique.add(normalized);
+    }
+    if (unique.size === 0)
+        return undefined;
+    return [...unique];
+}
+function normalizeDocs(docs) {
+    if (!docs)
+        return undefined;
+    const notes = normalizeStringList(docs.notes);
+    const antiPatterns = normalizeStringList(docs.antiPatterns);
+    const preconditions = normalizeStringList(docs.preconditions);
+    const postconditions = normalizeStringList(docs.postconditions);
+    const normalized = {
+        ...(notes ? { notes } : {}),
+        ...(antiPatterns ? { antiPatterns } : {}),
+        ...(preconditions ? { preconditions } : {}),
+        ...(postconditions ? { postconditions } : {}),
+    };
+    return Object.keys(normalized).length > 0 ? normalized : undefined;
+}
+export function normalizeDocmanOperationId(value) {
+    return value
+        .trim()
+        .replace(/\s+/g, '-')
+        .replace(/[^a-zA-Z0-9.-]/g, '-')
+        .replace(/-+/g, '-')
+        .replace(/\.+/g, '.')
+        .replace(/^-+/, '')
+        .replace(/-+$/, '')
+        .toLowerCase();
+}
+export function buildDocmanToolIdFromOperation(operationId) {
+    return `${TOOL_PREFIX}${normalizeDocmanOperationId(operationId).replace(/\./g, '-')}`;
+}
+function normalizeDocmanToolId(toolId) {
+    const normalized = String(toolId ?? '').trim().toLowerCase();
+    if (!normalized)
+        return normalized;
+    return normalized
+        .replace(/\s+/g, '-')
+        .replace(/[^a-z0-9-]/g, '-')
+        .replace(/-+/g, '-')
+        .replace(/^-+/, '')
+        .replace(/-+$/, '');
+}
+export function defineDocmanKitOperation(input) {
+    const operationId = normalizeDocmanOperationId(input.operationId);
+    if (!operationId)
+        throw new Error('invalid_docman_operation_id');
+    const serviceKey = normalizeNonEmpty(input.serviceKey);
+    if (!serviceKey)
+        throw new Error(`invalid_docman_operation_service_key:${operationId}`);
+    const serviceEntity = normalizeNonEmpty(input.serviceEntity);
+    if (!serviceEntity)
+        throw new Error(`invalid_docman_operation_service_entity:${operationId}`);
+    const methodName = normalizeNonEmpty(input.methodName);
+    if (!methodName)
+        throw new Error(`invalid_docman_operation_method_name:${operationId}`);
+    const toolIdSource = input.toolId ?? buildDocmanToolIdFromOperation(operationId);
+    const toolId = normalizeDocmanToolId(toolIdSource);
+    if (!toolId)
+        throw new Error(`invalid_docman_operation_tool_id:${operationId}`);
+    const summary = normalizeNonEmpty(input.summary ?? '');
+    const tags = normalizeTags(input.tags);
+    const examples = normalizeExamples(input.examples);
+    const docs = normalizeDocs(input.docs);
+    return {
+        operationId,
+        toolId,
+        serviceKey,
+        serviceEntity,
+        methodName,
+        kind: input.kind,
+        args: cloneArgs(input.args),
+        ...(summary ? { summary } : {}),
+        ...(tags ? { tags } : {}),
+        ...(input.sideEffect ? { sideEffect: input.sideEffect } : {}),
+        ...(input.inputSchema !== undefined ? { inputSchema: input.inputSchema } : {}),
+        ...(input.outputSchema !== undefined ? { outputSchema: input.outputSchema } : {}),
+        ...(input.policy !== undefined ? { policy: input.policy } : {}),
+        ...(examples ? { examples } : {}),
+        ...(docs ? { docs } : {}),
+    };
+}
+export function defineDocmanKitOperations(input) {
+    return input.map(defineDocmanKitOperation);
+}
+export function cloneDocmanOperationSpec(spec) {
+    const docs = normalizeDocs(spec.docs);
+    return {
+        ...spec,
+        args: cloneArgs(spec.args),
+        ...(spec.tags ? { tags: [...spec.tags] } : {}),
+        ...(spec.examples ? { examples: [...spec.examples] } : {}),
+        ...(docs ? { docs } : {}),
+    };
+}

package/dist/operations/executor.d.ts

@@ -0,0 +1,10 @@
+import type { DocmanOperationInput, DocmanOperationOutput, DocmanTypedOperationId } from './io-types.js';
+export declare function runDocmanKitOperationByToolId(toolId: string, input: unknown): Promise<unknown>;
+export declare function runDocmanKitOperationById<TId extends DocmanTypedOperationId>(operationId: TId, input: DocmanOperationInput<TId>): Promise<DocmanOperationOutput<TId>>;
+export declare function runDocmanKitOperationByTypedId<TId extends DocmanTypedOperationId>(operationId: TId, input: DocmanOperationInput<TId>): Promise<DocmanOperationOutput<TId>>;
+export declare function runDocmanKitOperation(input: unknown, identifier: {
+    toolId: string;
+} | {
+    operationId: string;
+}): Promise<unknown>;
+export declare function clearDocmanKitOperationCaches(): void;

package/dist/operations/executor.js

@@ -0,0 +1,269 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { Effect } from 'effect';
+import { config as loadDotEnv } from 'dotenv';
+import { createDocmanKitWithEnv } from '../domain-services/unified.js';
+import { getDocmanKitEnvConfig } from '../config/config.js';
+import { getDocmanOperationContractById, getDocmanOperationContractByToolId } from './contract.js';
+import { isDocmanScopeOwnedCreateOperation } from './scope-owned-create.js';
+const HOST_META_KEYS = new Set([
+    'scopeId',
+    'scopeResolution',
+    'tenantId',
+    'locale',
+    'fallbackLocale',
+    '__hostContext',
+]);
+const DOCMAN_OBJECT_INPUT_CUSTOM_OPERATION_IDS = new Set([
+    'document.index.build',
+    'document.index.get',
+    'document.summary.build',
+    'document.summary.get',
+    'document.search',
+    'document.scope.search',
+    'document.answer-pack',
+    'document.compose.fetch',
+    'document.publish.materialize',
+    'document-version.import-headings',
+    'document-version.set-current',
+]);
+let envLoaded = false;
+let cachedServices = null;
+function toRecord(input) {
+    if (!input || typeof input !== 'object' || Array.isArray(input))
+        return {};
+    return input;
+}
+function toSnakeCase(value) {
+    return value
+        .replace(/([a-z0-9])([A-Z])/g, '$1_$2')
+        .replace(/([A-Z])([A-Z][a-z])/g, '$1_$2')
+        .replace(/[-\s]+/g, '_')
+        .toLowerCase();
+}
+function normalizeNonEmpty(value) {
+    if (typeof value !== 'string')
+        return undefined;
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : undefined;
+}
+function resolveScopeIdValue(payload) {
+    return normalizeNonEmpty(payload.scopeId);
+}
+function normalizeScopeResolution(value) {
+    const normalized = normalizeNonEmpty(value);
+    if (normalized === 'explicit' || normalized === 'cascade')
+        return normalized;
+    return undefined;
+}
+function toObjectOrUndefined(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return undefined;
+    return value;
+}
+function sanitizePayload(payload, operation) {
+    const allowScopeId = operation?.args.some((arg) => arg.name === 'scopeId') === true;
+    const allowScopeResolution = operation?.args.some((arg) => arg.name === 'scopeResolution') === true;
+    const sanitized = {};
+    for (const [key, value] of Object.entries(payload)) {
+        if (key === 'scopeId' && allowScopeId) {
+            sanitized[key] = value;
+            continue;
+        }
+        if (key === 'scopeResolution' && allowScopeResolution) {
+            sanitized[key] = value;
+            continue;
+        }
+        if (HOST_META_KEYS.has(key))
+            continue;
+        sanitized[key] = value;
+    }
+    return sanitized;
+}
+function buildLocaleOptions(payload) {
+    const locale = normalizeNonEmpty(payload.locale);
+    const fallbackLocale = normalizeNonEmpty(payload.fallbackLocale);
+    if (!locale && !fallbackLocale)
+        return undefined;
+    return {
+        ...(locale ? { locale } : {}),
+        ...(fallbackLocale ? { fallbackLocale } : {}),
+    };
+}
+function loadEnvOnce() {
+    if (envLoaded)
+        return;
+    envLoaded = true;
+    const candidates = [
+        process.env.DOTENV_CONFIG_PATH,
+        process.env.DOCMAN_ENV_PATH,
+        path.resolve(process.cwd(), '.env'),
+        path.resolve(process.cwd(), '..', '.env'),
+        path.resolve(process.cwd(), '../..', '.env'),
+    ].filter(Boolean);
+    for (const candidate of candidates) {
+        if (!candidate)
+            continue;
+        if (!fs.existsSync(candidate))
+            continue;
+        loadDotEnv({ path: candidate, quiet: true });
+        break;
+    }
+}
+async function getServices() {
+    if (cachedServices)
+        return cachedServices;
+    cachedServices = (async () => {
+        loadEnvOnce();
+        const envConfig = getDocmanKitEnvConfig();
+        const { kit } = createDocmanKitWithEnv({
+            envConfig,
+            baseContext: { tenantId: envConfig.tenantId },
+        });
+        const services = await kit.createAll();
+        return Object.fromEntries(Object.entries(services));
+    })();
+    return cachedServices;
+}
+function resolveCustomArgValue(payload, arg) {
+    if (arg.name === 'options') {
+        const explicitOptions = toObjectOrUndefined(payload.options);
+        if (explicitOptions)
+            return explicitOptions;
+        return buildLocaleOptions(payload);
+    }
+    if (arg.name === 'scopeId') {
+        return resolveScopeIdValue(payload);
+    }
+    if (arg.name === 'scopeResolution') {
+        return normalizeScopeResolution(payload.scopeResolution);
+    }
+    return payload[arg.name];
+}
+function buildCrudArgs(operation, payload) {
+    const id = normalizeNonEmpty(payload.id);
+    if (operation.kind === 'list') {
+        const optionSeed = { ...(toObjectOrUndefined(payload.options) ?? {}) };
+        if (typeof payload.includeVersionInfo === 'boolean') {
+            optionSeed.includeVersionInfo = payload.includeVersionInfo;
+        }
+        const options = Object.keys(optionSeed).length > 0 ? optionSeed : undefined;
+        const filter = { ...(toObjectOrUndefined(payload.filter) ?? {}) };
+        const scopeId = resolveScopeIdValue(payload);
+        if (scopeId && filter.scopeId === undefined) {
+            filter.scopeId = scopeId;
+        }
+        const scopeResolution = normalizeScopeResolution(payload.scopeResolution);
+        if (scopeResolution && filter.scopeResolution === undefined) {
+            filter.scopeResolution = scopeResolution;
+        }
+        return [filter, options];
+    }
+    if (operation.kind === 'get') {
+        const options = toObjectOrUndefined(payload.options);
+        if (!id)
+            throw new Error('missing_required_id');
+        return [id, options];
+    }
+    if (operation.kind === 'create') {
+        const data = { ...(toObjectOrUndefined(payload.data) ?? {}) };
+        if (!data || Object.keys(data).length === 0)
+            throw new Error('missing_required_data');
+        const scopeId = resolveScopeIdValue(payload);
+        if (scopeId && data.scopeId === undefined && isDocmanScopeOwnedCreateOperation(operation.operationId)) {
+            data.scopeId = scopeId;
+        }
+        return [data];
+    }
+    if (operation.kind === 'update') {
+        if (!id)
+            throw new Error('missing_required_id');
+        const patch = toObjectOrUndefined(payload.patch);
+        if (!patch || Object.keys(patch).length === 0)
+            throw new Error('missing_required_patch');
+        return [id, patch];
+    }
+    if (operation.kind === 'delete') {
+        if (!id)
+            throw new Error('missing_required_id');
+        return [id];
+    }
+    return [];
+}
+function buildCustomArgs(operation, payload) {
+    if (operation.args.length === 0)
+        return [];
+    if (DOCMAN_OBJECT_INPUT_CUSTOM_OPERATION_IDS.has(operation.operationId)) {
+        return [sanitizePayload(payload, operation)];
+    }
+    if (operation.args.length === 1) {
+        const [onlyArg] = operation.args;
+        if ((onlyArg.name === 'input' || onlyArg.name === 'payload') && payload[onlyArg.name] === undefined) {
+            return [sanitizePayload(payload, operation)];
+        }
+    }
+    const args = [];
+    for (const arg of operation.args) {
+        const value = resolveCustomArgValue(payload, arg);
+        if (value === undefined && !arg.optional) {
+            throw new Error(`missing_required_${toSnakeCase(arg.name)}`);
+        }
+        args.push(value);
+    }
+    return args;
+}
+function buildMethodArgs(operation, payload) {
+    if (operation.kind === 'custom')
+        return buildCustomArgs(operation, payload);
+    return buildCrudArgs(operation, payload);
+}
+function resolveOperationByToolId(toolId) {
+    const operation = getDocmanOperationContractByToolId(toolId);
+    if (operation)
+        return operation;
+    throw new Error(`unknown_docman_tool:${toolId}`);
+}
+function resolveOperationById(operationId) {
+    const operation = getDocmanOperationContractById(operationId);
+    if (operation)
+        return operation;
+    throw new Error(`unknown_docman_operation:${operationId}`);
+}
+async function runResolvedOperation(operation, input) {
+    const payload = toRecord(input);
+    if (operation.serviceKey === '__calls__') {
+        throw new Error(`docman_special_operation_missing:${operation.operationId}`);
+    }
+    const services = await getServices();
+    const service = services[operation.serviceKey];
+    if (!service)
+        throw new Error(`docman_service_not_found:${operation.serviceKey}`);
+    const method = service[operation.methodName];
+    if (typeof method !== 'function') {
+        throw new Error(`docman_method_missing:${operation.serviceKey}.${operation.methodName}`);
+    }
+    const args = buildMethodArgs(operation, payload);
+    const effectResult = method.apply(service, args);
+    return Effect.runPromise(effectResult);
+}
+export async function runDocmanKitOperationByToolId(toolId, input) {
+    const operation = resolveOperationByToolId(toolId);
+    return runResolvedOperation(operation, input);
+}
+export async function runDocmanKitOperationById(operationId, input) {
+    const operation = resolveOperationById(operationId);
+    return runResolvedOperation(operation, input);
+}
+export async function runDocmanKitOperationByTypedId(operationId, input) {
+    return runDocmanKitOperationById(operationId, input);
+}
+export async function runDocmanKitOperation(input, identifier) {
+    if ('toolId' in identifier) {
+        return runDocmanKitOperationByToolId(identifier.toolId, input);
+    }
+    const operation = resolveOperationById(identifier.operationId);
+    return runResolvedOperation(operation, input);
+}
+export function clearDocmanKitOperationCaches() {
+    cachedServices = null;
+}

package/dist/operations/host-projection.d.ts

@@ -0,0 +1,11 @@
+export type DocmanHostProjectionMethod = 'GET' | 'POST' | 'PATCH' | 'DELETE';
+export type DocmanHostRouteProjectionEntry = {
+    id: string;
+    method: DocmanHostProjectionMethod;
+    pattern: string;
+    operation: string;
+    summary?: string;
+};
+export declare function buildDocmanHostRouteProjection(options?: {
+    refresh?: boolean;
+}): DocmanHostRouteProjectionEntry[];