engineering-memory 1.11.7 → 1.11.9

package/runtime/dist/src/runtime/bridge-service.js

@@ -399,9 +399,15 @@ export class BridgeService {
                 (repository.projectId && repository.projectId !== projectId)) {
                 throw refuse('The live task belongs to a different project than the one this repository is bound to.', 'project.resolve');
             }
-            if (pointer?.worktreeGeneration && this.dependencies.worktreePool) {
+            const adoptable = pointer &&
+                !pointer.worktreeGeneration &&
+                normalizeTaskMode(pointer.mode) !== 'read_only' &&
+                this.dependencies.worktreePool
+                ? await this.dependencies.worktreePool.find(projectId, taskSlug, repository.repoRoot)
+                : null;
+            if (pointer && this.dependencies.worktreePool && (pointer.worktreeGeneration || adoptable)) {
                 const pool = this.dependencies.worktreePool;
-                const previous = await pool.find(projectId, taskSlug, repository.repoRoot);
+                const previous = adoptable ?? (await pool.find(projectId, taskSlug, repository.repoRoot));
                 if (previous && previous.repoRoot !== repository.repoRoot)
                     return asJsonValue({
                         worktreeResumeRequired: true,
@@ -411,8 +417,11 @@ export class BridgeService {
                         nextAction: 'Call session.resume from this returned repoRoot and use it for every subsequent command.',
                     });
                 const sourceCommit = previous?.baseCommit ?? pointer.source?.sourceCommit;
+                const branch = pointer.worktreeGeneration
+                    ? pointer.branch
+                    : (previous?.branch ?? pointer.branch);
                 if ((!sourceCommit && !(previous && previous.baseCommit === null && !previous.managed)) ||
-                    pointer.branch === undefined)
+                    branch === undefined)
                     throw refuse('The task branch and base must be restored before resuming its worktree.', 'worktree.reconcile');
                 const allocation = await pool.allocate({
                     projectId,
@@ -420,7 +429,7 @@ export class BridgeService {
                     repoFingerprint: repository.repoFingerprint,
                     repoRoot: repository.repoRoot,
                     externalTaskId: taskSlug,
-                    branch: pointer.branch,
+                    branch,
                     baseCommit: sourceCommit ?? null,
                     keepCurrent: previous ? !previous.managed : false,
                     resume: true,
@@ -433,6 +442,7 @@ export class BridgeService {
                     ...pointer,
                     worktreeId: sha256(allocation.repoRoot),
                     worktreeGeneration: allocation.generation,
+                    ...(branch !== undefined ? { branch } : {}),
                 };
                 await this.dependencies.activeContexts.save(pointer);
                 if (allocation.repoRoot !== repository.repoRoot)
@@ -449,7 +459,7 @@ export class BridgeService {
                 const recoveredClose = await this.retryCloseIntent(repository, pointer);
                 return asJsonValue({
                     backend: { close: recoveredClose },
-                    worktree: this.poolAllocations.get(repository.repoRoot) ?? null,
+                    worktree: (await this.ownedAllocation(projectId, repository.repoRoot)) ?? null,
                     pendingQuestionnaires,
                     repository: publicRepository(repository),
                     localJournal: await this.dependencies.journal.load(projectId, taskSlug),
@@ -632,7 +642,7 @@ export class BridgeService {
             return asJsonValue({
                 backend,
                 repository: publicRepository(repository),
-                worktree: this.poolAllocations.get(repository.repoRoot) ?? null,
+                worktree: (await this.ownedAllocation(projectId, repository.repoRoot)) ?? null,
                 localJournal,
                 pendingQuestionnaires,
                 synchronization: {
@@ -731,7 +741,7 @@ export class BridgeService {
                 transitionTaskVersion = refreshed.taskVersion;
             }
             if (decision && this.dependencies.worktreePool) {
-                const allocation = this.poolAllocations.get(repository.repoRoot);
+                const allocation = await this.ownedAllocation(pointer.projectId, repository.repoRoot);
                 if (!allocation || allocation.externalTaskId !== pointer.taskSlug)
                     throw refuse('Choose this task branch and use its allocated repoRoot before transitioning to write.', 'task.branch');
                 await this.dependencies.worktreePool.assertOwnership(pointer.projectId, repository.repoRoot, allocation.generation);
@@ -792,16 +802,14 @@ export class BridgeService {
                     await this.dependencies.repositories.git
                         .branchStore(repository.repoRoot)
                         .bind(preparedPointer.projectId, preparedPointer.taskSlug, preparedPointer.taskId);
+                    const allocation = await this.ownedAllocation(preparedPointer.projectId, repository.repoRoot);
                     await this.dependencies.activeContexts.save({
                         ...preparedPointer,
                         worktreeId: sha256(repository.repoRoot),
                         branch: typeof preparedTask?.branch === 'string' ? preparedTask.branch : decision.branch,
                         mode: 'write',
-                        ...(this.poolAllocations.get(repository.repoRoot)
-                            ? { worktreeGeneration: this.poolAllocations.get(repository.repoRoot).generation }
-                            : {}),
+                        ...(allocation ? { worktreeGeneration: allocation.generation } : {}),
                     });
-                    const allocation = this.poolAllocations.get(repository.repoRoot);
                     if (allocation && this.dependencies.worktreePool) {
                         await this.dependencies.worktreePool.bind(preparedPointer.projectId, repository.repoRoot, allocation.generation, preparedPointer.taskId);
                         allocation.taskId = preparedPointer.taskId;
@@ -1884,11 +1892,26 @@ export class BridgeService {
             const pool = this.dependencies.worktreePool;
             if (!projectId || !pool)
                 throw refuse('Resolve the project with a pool-capable client.', 'project.resolve');
-            if (operation === 'list' || operation === 'reconcile')
+            if (operation === 'list' || operation === 'reconcile') {
+                const managedRoot = await pool.managedRoot();
                 return asJsonValue({
                     items: await pool.reconcile(projectId, repository.repoRoot, await this.poolPolicy()),
                     selected: await pool.forPath(projectId, repository.repoRoot),
+                    managedRoot,
+                    ...(managedRoot.problem || managedRoot.synced
+                        ? {
+                            notice: [
+                                ...(managedRoot.problem ? [managedRoot.problem] : []),
+                                ...(managedRoot.synced
+                                    ? [
+                                        `Managed worktrees are created under ${managedRoot.root}, which a cloud sync client watches, so every Git operation there is re-scanned and uploaded. To create new worktrees elsewhere, write {"root": "<absolute directory>"} to ${managedRoot.override}; it takes effect for the next allocation, and existing worktrees keep working where they are.`,
+                                    ]
+                                    : []),
+                            ].join(' '),
+                        }
+                        : {}),
                 });
+            }
             if (operation === 'release_unowned') {
                 const entry = await pool.forPath(projectId, repository.repoRoot);
                 if (!entry || !input.sourceCommit || !input.generation || !input.decisionId)
@@ -1974,12 +1997,46 @@ export class BridgeService {
             resume: Boolean(existing),
         }, await this.poolPolicy(true));
         this.poolAllocations.set(allocation.repoRoot, allocation);
+        if (existing && allocation.repoRoot === repository.repoRoot) {
+            const current = await this.dependencies.activeContexts.loadForSlug(repository.repoFingerprint, input.externalTaskId);
+            if (current &&
+                current.taskSlug === input.externalTaskId &&
+                !current.worktreeGeneration &&
+                normalizeTaskMode(current.mode) !== 'read_only')
+                await this.dependencies.activeContexts.save({
+                    ...current,
+                    worktreeId: sha256(allocation.repoRoot),
+                    worktreeGeneration: allocation.generation,
+                    ...(current.branch === undefined && allocation.branch !== null
+                        ? { branch: allocation.branch }
+                        : {}),
+                });
+        }
         return asJsonValue({
             ...allocation,
             kept: !allocation.managed,
             nextAction: 'Run every file, terminal, lifecycle and delivery operation from this repoRoot. Use task.heartbeat during long work. Pause before handing the task to another client.',
         });
     }
+    adoptOwned(repoRoot, entry) {
+        const cached = this.poolAllocations.get(repoRoot);
+        if (cached)
+            return cached;
+        const pool = this.dependencies.worktreePool;
+        if (!entry || !pool || !pool.owns(entry))
+            return undefined;
+        this.poolAllocations.set(repoRoot, entry);
+        return entry;
+    }
+    async ownedAllocation(projectId, repoRoot) {
+        const cached = this.poolAllocations.get(repoRoot);
+        if (cached)
+            return cached;
+        const pool = this.dependencies.worktreePool;
+        if (!pool)
+            return undefined;
+        return this.adoptOwned(repoRoot, await pool.forPath(projectId, repoRoot));
+    }
     async assertPoolPointer(repository, pointer) {
         const pool = this.dependencies.worktreePool;
         if (!pool)
@@ -1987,11 +2044,10 @@ export class BridgeService {
         const entry = await pool.forPath(pointer.projectId, repository.repoRoot);
         if (!entry && !pointer.worktreeGeneration)
             return; // existing unmanaged tasks retain their legacy reservation
-        const owned = this.poolAllocations.get(repository.repoRoot);
-        if (!entry ||
-            !owned ||
-            owned.generation !== pointer.worktreeGeneration ||
-            entry.externalTaskId !== pointer.taskSlug)
+        if (entry && entry.externalTaskId !== pointer.taskSlug)
+            throw refuse(`This directory is allocated to task ${entry.externalTaskId}. Resume this task from its own worktree, or reconcile the pool to release the directory.`, 'worktree.reconcile');
+        const owned = this.adoptOwned(repository.repoRoot, entry);
+        if (!entry || !owned || owned.generation !== pointer.worktreeGeneration)
             throw refuse('Resume this task to acquire its worktree before writing or delivering.', 'session.resume');
         await pool.assertOwnership(pointer.projectId, repository.repoRoot, owned.generation);
     }
@@ -2117,7 +2173,9 @@ export class BridgeService {
                 if (!abandoned || abandoned.abandoned !== true) {
                     throw refuse('The backend did not record the abandonment, so the task is still open.', 'session.resume');
                 }
-                const allocation = this.poolAllocations.get(repository.repoRoot);
+                const allocation = repository.projectId
+                    ? await this.ownedAllocation(repository.projectId, repository.repoRoot)
+                    : this.poolAllocations.get(repository.repoRoot);
                 if (allocation && this.dependencies.worktreePool) {
                     await this.dependencies.worktreePool.pause(allocation.projectId, allocation.repoRoot, allocation.generation);
                     this.poolAllocations.delete(repository.repoRoot);
@@ -3385,7 +3443,9 @@ export class BridgeService {
             taskChanges,
         });
         await this.dependencies.activeContexts.clearCloseIntent(repository.repoFingerprint, String(body.taskId));
-        const allocation = this.poolAllocations.get(repository.repoRoot);
+        const allocation = repository.projectId
+            ? await this.ownedAllocation(repository.projectId, repository.repoRoot)
+            : this.poolAllocations.get(repository.repoRoot);
         if (allocation && this.dependencies.worktreePool)
             await this.dependencies.worktreePool.delivery(allocation.projectId, repository.repoRoot, allocation.generation);
         else
@@ -3471,7 +3531,7 @@ export class BridgeService {
         try {
             const allocation = await this.dependencies.worktreePool?.forTask(taskId);
             if (allocation) {
-                const owned = this.poolAllocations.get(allocation.repoRoot);
+                const owned = this.adoptOwned(allocation.repoRoot, allocation);
                 if (!owned || owned.generation !== allocation.generation)
                     throw refuse('Resume the task in its owned worktree before this operation.', 'session.resume');
                 await this.dependencies.worktreePool.assertOwnership(allocation.projectId, allocation.repoRoot, owned.generation);

package/runtime/dist/src/runtime/create-bridge-service.js

@@ -0,0 +1,82 @@
+import { WorktreePool } from './worktree-pool.js';
+import { WorktreePolicyCache } from './worktree-policy.js';
+import { BrowserAuthCoordinator } from '../auth/browser-auth.js';
+import { createCredentialStore } from '../auth/credential-store.js';
+import { EtagCache } from '../cache/etag-cache.js';
+import { apiNamespaceKey, apiStateRoot, endpoints, loadBridgeConfig } from '../config.js';
+import { GitInspector } from '../git/git-inspector.js';
+import { VerificationGate } from '../git/verification-gate.js';
+import { JournalStore } from '../journal/journal-store.js';
+import { RepositoryResolver } from '../project/repository.js';
+import { ApiClient } from './api-client.js';
+import { BridgeService } from './bridge-service.js';
+import { OfflineOutbox } from './offline-outbox.js';
+import { ActiveContextStore } from './active-context-store.js';
+import { RepositoryDecisionStore } from './repository-decision-store.js';
+import { ShadowNoticeStore } from './shadow-notice-store.js';
+import { UpdateChoiceStore } from './update-choice-store.js';
+import { PrincipalStateGuard } from './principal-state.js';
+import { OnboardingStore } from './onboarding-store.js';
+import { QuestionnaireStore } from './questionnaire-store.js';
+export function createBridgeService(options = {}) {
+    const config = loadBridgeConfig();
+    const apiNamespace = apiNamespaceKey(config.apiBaseUrl);
+    const stateRoot = apiStateRoot(config);
+    const credentials = createCredentialStore({
+        service: config.credentialService,
+        account: `${config.credentialAccount}:${apiNamespace}`,
+        stateRoot,
+    });
+    const cache = new EtagCache({
+        stateRoot,
+        maxEntries: config.cacheMaxEntries,
+        maxBytes: config.cacheMaxBytes,
+        maxAgeMs: config.cacheMaxAgeMs,
+    });
+    const client = new ApiClient({
+        baseUrl: config.apiBaseUrl,
+        timeoutMs: config.requestTimeoutMs,
+        credentials,
+        cache,
+        refreshPath: endpoints.authRefresh,
+    });
+    const git = new GitInspector();
+    const outbox = new OfflineOutbox(stateRoot);
+    const activeContexts = new ActiveContextStore(stateRoot);
+    const repositoryDecisions = new RepositoryDecisionStore(stateRoot);
+    const updateChoices = new UpdateChoiceStore(stateRoot);
+    const shadowNotices = new ShadowNoticeStore(stateRoot);
+    const worktreePool = new WorktreePool(stateRoot, {
+        ...(options.ownerId ? { ownerId: options.ownerId } : {}),
+        pendingWork: async (entry) => {
+            if (!entry.taskId)
+                return false;
+            const pointer = await activeContexts.loadForTask(entry.repoFingerprint, entry.taskId);
+            return Boolean(pointer?.verificationIntent ||
+                pointer?.closeIntent ||
+                (await outbox.listForTask(entry.taskId)).length);
+        },
+    });
+    const gate = new VerificationGate(stateRoot, git, outbox, undefined, worktreePool);
+    const principalState = new PrincipalStateGuard(stateRoot, credentials, cache, outbox, activeContexts, gate);
+    return new BridgeService({
+        worktreePool,
+        worktreePolicy: new WorktreePolicyCache(stateRoot),
+        client,
+        credentials,
+        browserAuth: new BrowserAuthCoordinator(client, credentials),
+        repositories: new RepositoryResolver(git, config.markerSchemaVersion, stateRoot),
+        journal: new JournalStore(stateRoot),
+        outbox,
+        gate,
+        activeContexts,
+        repositoryDecisions,
+        updateChoices,
+        shadowNotices,
+        questionnaires: new QuestionnaireStore(stateRoot),
+        onboarding: new OnboardingStore(stateRoot),
+        clientVersion: options.clientVersion === undefined ? config.clientVersion : options.clientVersion,
+        principalState,
+    });
+}
+//# sourceMappingURL=create-bridge-service.js.map

package/runtime/dist/src/runtime/runtime-entry.js

@@ -0,0 +1,16 @@
+import { registerAllTools } from '../mcp/server.js';
+import { recordingHost } from '../mcp/tool-host.js';
+import { createBridgeService } from './create-bridge-service.js';
+export function collectTools(service, server) {
+    const recording = recordingHost(server);
+    registerAllTools(recording.host, service);
+    return recording.tools;
+}
+export function createRuntime(options) {
+    const service = createBridgeService({
+        ownerId: options.ownerId,
+        clientVersion: options.clientVersion,
+    });
+    return { tools: collectTools(service, options.server) };
+}
+//# sourceMappingURL=runtime-entry.js.map

package/runtime/dist/src/runtime/runtime-host.js

@@ -0,0 +1,265 @@
+import { randomUUID } from 'node:crypto';
+import { readFile, stat } from 'node:fs/promises';
+import { isAbsolute, join, resolve } from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { z } from 'zod';
+export const currentReleaseSchema = z.object({
+    product: z.literal('engineering-memory'),
+    schemaVersion: z.literal(1),
+    path: z.string().min(1),
+    version: z.string().min(1).nullable().optional(),
+    sourceHash: z.string().optional(),
+    bridgeEntry: z.string().optional(),
+    gateEntry: z.string().optional(),
+});
+export const runtimeEntryRelativePath = ['dist', 'src', 'runtime', 'runtime-entry.js'];
+const emptyObjectSchema = { type: 'object', properties: {} };
+export async function readCurrentRelease(currentPath) {
+    let raw;
+    try {
+        raw = await readFile(currentPath, 'utf8');
+    }
+    catch (error) {
+        return { problem: `${currentPath} cannot be read: ${describe(error)}` };
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        return { problem: `${currentPath} is not valid JSON` };
+    }
+    const release = currentReleaseSchema.safeParse(parsed);
+    if (!release.success)
+        return { problem: `${currentPath} does not describe a release` };
+    const path = isAbsolute(release.data.path)
+        ? resolve(release.data.path)
+        : resolve(currentPath, '..', release.data.path);
+    return { release: release.data, path };
+}
+export async function importRelease(releasePath) {
+    const entry = join(releasePath, ...runtimeEntryRelativePath);
+    const loaded = (await import(pathToFileURL(entry).href));
+    if (typeof loaded.createRuntime !== 'function')
+        throw new Error(`${entry} does not export createRuntime`);
+    return { createRuntime: loaded.createRuntime };
+}
+export class RuntimeHost {
+    options;
+    ownerId;
+    registered = new Map();
+    specs = new Map();
+    loadedPath;
+    loadedVersion;
+    refreshing;
+    failedPath;
+    seen;
+    timer;
+    started = false;
+    constructor(options) {
+        this.options = options;
+        this.ownerId = options.ownerId ?? randomUUID();
+        this.loadedPath = resolve(options.release.path);
+        this.loadedVersion = options.release.version;
+    }
+    get version() {
+        return this.loadedVersion;
+    }
+    get releasePath() {
+        return this.loadedPath;
+    }
+    start() {
+        if (this.started)
+            return;
+        this.started = true;
+        this.apply(this.instantiate(this.options.release.module, this.options.release.version));
+    }
+    watch(intervalMs) {
+        if (this.timer || !this.options.currentPath)
+            return;
+        this.timer = setInterval(() => {
+            void this.refresh();
+        }, intervalMs);
+        this.timer.unref();
+    }
+    stop() {
+        if (this.timer)
+            clearInterval(this.timer);
+        this.timer = undefined;
+    }
+    async refresh() {
+        if (!this.options.currentPath || !this.started)
+            return false;
+        this.refreshing ??= this.reload().finally(() => {
+            this.refreshing = undefined;
+        });
+        return this.refreshing;
+    }
+    async reload() {
+        const currentPath = this.options.currentPath;
+        let marker;
+        try {
+            marker = await stat(currentPath);
+        }
+        catch {
+            return false;
+        }
+        if (this.seen && this.seen.mtimeMs === marker.mtimeMs && this.seen.size === marker.size)
+            return false;
+        this.seen = { mtimeMs: marker.mtimeMs, size: marker.size };
+        const current = await readCurrentRelease(currentPath);
+        if ('problem' in current) {
+            this.log(`Engineering Memory bridge keeps release ${this.describeLoaded()}: ${current.problem}`);
+            return false;
+        }
+        if (current.path === this.loadedPath || current.path === this.failedPath)
+            return false;
+        const version = current.release.version ?? null;
+        try {
+            const module = await (this.options.load ?? importRelease)(current.path);
+            this.apply(this.instantiate(module, version));
+        }
+        catch (error) {
+            this.failedPath = current.path;
+            this.log(`Engineering Memory bridge keeps release ${this.describeLoaded()} because ${current.path} could not be loaded: ${describe(error)}`);
+            return false;
+        }
+        this.loadedPath = current.path;
+        this.loadedVersion = version;
+        this.failedPath = undefined;
+        this.log(`Engineering Memory bridge switched to release ${this.describeLoaded()}`);
+        return true;
+    }
+    instantiate(module, version) {
+        const runtime = module.createRuntime({
+            ownerId: this.ownerId,
+            clientVersion: version,
+            server: this.options.server.server,
+        });
+        if (!runtime || !Array.isArray(runtime.tools))
+            throw new Error('createRuntime did not return a tool list');
+        const names = new Set();
+        for (const spec of runtime.tools) {
+            if (typeof spec.name !== 'string' || !spec.name)
+                throw new Error('createRuntime returned a tool without a name');
+            if (names.has(spec.name))
+                throw new Error(`Tool ${spec.name} is defined twice`);
+            if (typeof spec.callback !== 'function')
+                throw new Error(`Tool ${spec.name} has no callback`);
+            names.add(spec.name);
+        }
+        return runtime;
+    }
+    apply(runtime) {
+        const names = new Set();
+        const register = this.options.server.registerTool.bind(this.options.server);
+        for (const spec of runtime.tools) {
+            names.add(spec.name);
+            this.specs.set(spec.name, spec);
+            const signature = toolSignature(spec.config);
+            const existing = this.registered.get(spec.name);
+            if (!existing) {
+                const tool = register(spec.name, { ...spec.config, inputSchema: this.inputSchemaOf(spec.name) }, this.dispatcher(spec.name));
+                this.registered.set(spec.name, { tool, signature });
+            }
+            else if (existing.signature !== signature) {
+                existing.tool.update({
+                    ...(spec.config.title !== undefined ? { title: spec.config.title } : {}),
+                    ...(spec.config.description !== undefined
+                        ? { description: spec.config.description }
+                        : {}),
+                    ...(spec.config.outputSchema !== undefined
+                        ? { outputSchema: spec.config.outputSchema }
+                        : {}),
+                    ...(spec.config.annotations !== undefined
+                        ? { annotations: spec.config.annotations }
+                        : {}),
+                });
+                existing.signature = signature;
+            }
+        }
+        for (const [name, entry] of [...this.registered]) {
+            if (names.has(name))
+                continue;
+            entry.tool.remove();
+            this.registered.delete(name);
+            this.specs.delete(name);
+        }
+    }
+    inputSchemaOf(name) {
+        const jsonSchema = (io) => (options) => {
+            const schema = this.specs.get(name)?.config.inputSchema;
+            if (!schema)
+                return emptyObjectSchema;
+            return schema['~standard'].jsonSchema[io](options);
+        };
+        const props = {
+            version: 1,
+            vendor: 'engineering-memory',
+            validate: (value) => ({ value }),
+            jsonSchema: { input: jsonSchema('input'), output: jsonSchema('output') },
+        };
+        return { '~standard': props };
+    }
+    dispatcher(name) {
+        return async (args, context) => {
+            await this.refresh();
+            const spec = this.specs.get(name);
+            if (!spec)
+                throw new Error(`Tool ${name} is no longer provided by this bridge release; list the tools again and use the current lifecycle.`);
+            const schema = spec.config.inputSchema;
+            if (!schema)
+                return spec.callback(context);
+            const outcome = await schema['~standard'].validate(args ?? {});
+            if (outcome.issues && outcome.issues.length > 0)
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `Input validation error: Invalid arguments for tool ${name}: ${outcome.issues
+                                .map((issue) => formatIssue(issue))
+                                .join(', ')}`,
+                        },
+                    ],
+                    isError: true,
+                };
+            return spec.callback(outcome.value, context);
+        };
+    }
+    describeLoaded() {
+        return this.loadedVersion ?? this.loadedPath;
+    }
+    log(message) {
+        this.options.log?.(message);
+    }
+}
+export function toolSignature(config) {
+    return JSON.stringify({
+        title: config.title ?? null,
+        description: config.description ?? null,
+        annotations: config.annotations ?? null,
+        input: jsonSchemaOf(config.inputSchema),
+        output: jsonSchemaOf(config.outputSchema),
+    });
+}
+function jsonSchemaOf(schema) {
+    if (!schema)
+        return null;
+    try {
+        return schema['~standard'].jsonSchema.input({ target: 'draft-2020-12' });
+    }
+    catch {
+        return randomUUID();
+    }
+}
+function formatIssue(issue) {
+    if (!issue.path?.length)
+        return issue.message;
+    return `${issue.path
+        .map((segment) => String(typeof segment === 'object' && segment !== null ? segment.key : segment))
+        .join('.')}: ${issue.message}`;
+}
+function describe(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+//# sourceMappingURL=runtime-host.js.map