@ontrails/trails 1.0.0-beta.14 → 1.0.0-beta.15

package/src/trails/topo-read-support.ts

@@ -1,65 +1,69 @@
 /**
  * Read-only topo store consumer helpers.
  *
- * Extracted from topo-support.ts so this branch (trl-132) owns its own file,
- * keeping absorb routing clean across the stack.
+ * Extracted from topo-support.ts to isolate read-only store consumer helpers,
+ * keeping module boundaries clean.
  */
 
 import { existsSync } from 'node:fs';
 import { join } from 'node:path';
 
-import type { Topo } from '@ontrails/core';
 import {
   ConflictError,
   createTopoStore,
   InternalError,
+  listTopoSnapshots,
   NotFoundError,
   Result,
 } from '@ontrails/core';
-import type { TopoSaveRecord } from '@ontrails/core/internal/topo-saves';
-import { listTopoSaves } from '@ontrails/core/internal/topo-saves';
+import type { Topo, TopoSnapshot } from '@ontrails/core';
 import {
-  openReadTrailsDb,
-  resolveTrailsDbPath,
-  resolveTrailsDir,
+  deriveTrailsDbPath,
+  deriveTrailsDir,
 } from '@ontrails/core/internal/trails-db';
-import { readTrailheadLockData } from '@ontrails/schema';
+import { readSurfaceLockData } from '@ontrails/schema';
 
 import type { BriefReport, SurveyListReport } from './topo-reports.js';
 import type { TopoSummaryReport, TopoVerifyReport } from './topo-support.js';
 import { REPORT_CONTRACT_VERSION, REPORT_VERSION } from './topo-constants.js';
 import {
-  createCurrentTopoSave,
+  createCurrentTopoSnapshot,
+  deriveRootDir,
   LOCK_PATH,
-  resolveRootDir,
 } from './topo-support.js';
 
 // ---------------------------------------------------------------------------
 // Internal types
 // ---------------------------------------------------------------------------
 
-interface StoredTrailheadMapEntry {
-  readonly detours?: Readonly<Record<string, readonly string[]>>;
-  readonly kind: 'provision' | 'signal' | 'trail';
+interface StoredSurfaceMapEntry {
+  readonly detours?: readonly {
+    readonly on: string;
+    readonly maxAttempts: number;
+  }[];
+  readonly kind: 'resource' | 'signal' | 'trail';
 }
 
 interface CurrentTrailDetail {
   readonly crosses: string[];
   readonly description: string | null;
-  readonly detours: Readonly<Record<string, readonly string[]>> | null;
+  readonly detours:
+    | readonly { readonly on: string; readonly maxAttempts: number }[]
+    | null;
   readonly examples: unknown[];
   readonly id: string;
   readonly intent: 'destroy' | 'read' | 'write';
   readonly kind: string;
-  readonly provisions: string[];
+  readonly pattern: string | null;
+  readonly resources: string[];
   readonly safety: string;
 }
 
-interface CurrentProvisionDetail {
+interface CurrentResourceDetail {
   readonly description: string | null;
   readonly health: 'available' | 'none';
   readonly id: string;
-  readonly kind: 'provision';
+  readonly kind: 'resource';
   readonly lifetime: 'singleton';
   readonly usedBy: string[];
 }
@@ -68,18 +72,17 @@ interface CurrentProvisionDetail {
 // Store helpers
 // ---------------------------------------------------------------------------
 
-const topoStoreRef = (saveId: string) => ({ saveId }) as const;
+const topoStoreRef = (snapshotId: string) => ({ snapshotId }) as const;
 
 const hasCommittedLock = (trailsDir: string): boolean =>
-  existsSync(join(trailsDir, 'trails.lock')) ||
-  existsSync(join(trailsDir, 'trailhead.lock'));
+  existsSync(join(trailsDir, 'trails.lock'));
 
-const readTrailheadEntries = (
-  trailheadMapJson: string
-): readonly StoredTrailheadMapEntry[] =>
+const readSurfaceEntries = (
+  surfaceMapJson: string
+): readonly StoredSurfaceMapEntry[] =>
   (
-    JSON.parse(trailheadMapJson) as {
-      readonly entries: readonly StoredTrailheadMapEntry[];
+    JSON.parse(surfaceMapJson) as {
+      readonly entries: readonly StoredSurfaceMapEntry[];
     }
   ).entries;
 
@@ -87,32 +90,30 @@ const buildBriefReportFromStore = (
   app: Topo,
   store: ReturnType<typeof createTopoStore>,
   ref: ReturnType<typeof topoStoreRef>,
-  save: TopoSaveRecord
+  snapshot: TopoSnapshot
 ): BriefReport => {
-  const trails = store.trails.list({ save: ref });
+  const trails = store.trails.list({ snapshot: ref });
   const exportRecord = store.exports.get(ref);
   const trailEntries =
     exportRecord === undefined
       ? []
-      : readTrailheadEntries(exportRecord.trailheadMapJson).filter(
+      : readSurfaceEntries(exportRecord.surfaceMapJson).filter(
           (entry) => entry.kind === 'trail'
         );
 
   return {
     contractVersion: REPORT_CONTRACT_VERSION,
     features: {
-      detours: trailEntries.some(
-        (entry) => (Object.keys(entry.detours ?? {}).length ?? 0) > 0
-      ),
+      detours: trailEntries.some((entry) => (entry.detours ?? []).length > 0),
       examples: trails.some((trail) => trail.hasExamples),
       outputSchemas: trails.some((trail) => trail.hasOutput),
-      provisions: save.provisionCount > 0,
-      signals: save.signalCount > 0,
+      resources: snapshot.resourceCount > 0,
+      signals: snapshot.signalCount > 0,
     },
     name: app.name,
-    provisions: save.provisionCount,
-    signals: save.signalCount,
-    trails: save.trailCount,
+    resources: snapshot.resourceCount,
+    signals: snapshot.signalCount,
+    trails: snapshot.trailCount,
     version: REPORT_VERSION,
   };
 };
@@ -121,8 +122,8 @@ const buildSurveyListFromStore = (
   store: ReturnType<typeof createTopoStore>,
   ref: ReturnType<typeof topoStoreRef>
 ): SurveyListReport => {
-  const trails = store.trails.list({ save: ref });
-  const provisions = store.provisions.list({ save: ref });
+  const trails = store.trails.list({ snapshot: ref });
+  const resources = store.resources.list({ snapshot: ref });
 
   return {
     count: trails.length,
@@ -132,43 +133,46 @@ const buildSurveyListFromStore = (
       kind: trail.kind,
       safety: trail.safety,
     })),
-    provisionCount: provisions.length,
-    provisions: provisions.map((provision) => ({
-      description: provision.description,
-      health: provision.health,
-      id: provision.id,
-      kind: provision.kind,
-      lifetime: provision.lifetime,
-      usedBy: provision.usedBy,
+    resourceCount: resources.length,
+    resources: resources.map((resource) => ({
+      description: resource.description,
+      health: resource.health,
+      id: resource.id,
+      kind: resource.kind,
+      lifetime: resource.lifetime,
+      usedBy: resource.usedBy,
     })),
   };
 };
 
 const buildTrailDetailFromStore = (
-  detail: ReturnType<ReturnType<typeof createTopoStore>['trails']['get']>
+  detail: NonNullable<
+    ReturnType<ReturnType<typeof createTopoStore>['trails']['get']>
+  >
 ): CurrentTrailDetail => ({
-  crosses: [...(detail?.crosses ?? [])],
-  description: detail?.description ?? null,
-  detours: detail?.detours ?? null,
-  examples: [...(detail?.examples ?? [])],
-  id: detail?.id ?? '',
-  intent: detail?.intent ?? 'write',
-  kind: detail?.kind ?? 'trail',
-  provisions: [...(detail?.provisions ?? [])],
-  safety: detail?.safety ?? '-',
+  crosses: [...detail.crosses],
+  description: detail.description,
+  detours: detail.detours,
+  examples: [...detail.examples],
+  id: detail.id,
+  intent: detail.intent,
+  kind: detail.kind,
+  pattern: detail.pattern,
+  resources: [...detail.resources],
+  safety: detail.safety,
 });
 
-const buildProvisionDetailFromStore = (
-  provision: NonNullable<
-    ReturnType<ReturnType<typeof createTopoStore>['provisions']['get']>
+const buildResourceDetailFromStore = (
+  resource: NonNullable<
+    ReturnType<ReturnType<typeof createTopoStore>['resources']['get']>
   >
-): CurrentProvisionDetail => ({
-  description: provision.description,
-  health: provision.health,
-  id: provision.id,
-  kind: provision.kind,
-  lifetime: provision.lifetime,
-  usedBy: [...provision.usedBy],
+): CurrentResourceDetail => ({
+  description: resource.description,
+  health: resource.health,
+  id: resource.id,
+  kind: resource.kind,
+  lifetime: resource.lifetime,
+  usedBy: [...resource.usedBy],
 });
 
 // ---------------------------------------------------------------------------
@@ -178,8 +182,9 @@ const buildProvisionDetailFromStore = (
 /**
  * Run a read callback against the latest topo store state.
  *
- * Uses the most recent existing save when available, only creating a new save
- * when no prior save exists. This avoids unbounded save accumulation from
+ * Uses the most recent existing snapshot when available, only creating a new
+ * snapshot when no prior snapshot exists. This avoids unbounded snapshot
+ * accumulation from
  * read-only operations like survey, guide, and show.
  */
 const withCurrentTopoStore = <T>(
@@ -188,24 +193,14 @@ const withCurrentTopoStore = <T>(
   read: (
     store: ReturnType<typeof createTopoStore>,
     ref: ReturnType<typeof topoStoreRef>,
-    save: TopoSaveRecord
+    snapshot: TopoSnapshot
   ) => T
 ): T => {
-  const dbPath = resolveTrailsDbPath({ rootDir });
-  const existingSave = existsSync(dbPath)
-    ? (() => {
-        const db = openReadTrailsDb({ rootDir });
-        try {
-          return listTopoSaves(db)[0];
-        } finally {
-          db.close();
-        }
-      })()
-    : undefined;
-
-  const save = existingSave ?? createCurrentTopoSave(app, { rootDir });
+  const [existingSnapshot] = listTopoSnapshots({ limit: 1, rootDir });
+  const snapshot =
+    existingSnapshot ?? createCurrentTopoSnapshot(app, { rootDir });
   const store = createTopoStore({ rootDir });
-  return read(store, topoStoreRef(save.id), save);
+  return read(store, topoStoreRef(snapshot.id), snapshot);
 };
 
 // ---------------------------------------------------------------------------
@@ -216,11 +211,11 @@ export const buildTopoSummary = (
   app: Topo,
   options?: { readonly rootDir?: string }
 ): TopoSummaryReport => {
-  const rootDir = resolveRootDir(options?.rootDir);
-  const trailsDir = resolveTrailsDir({ rootDir });
-  return withCurrentTopoStore(app, rootDir, (store, ref, save) => ({
-    app: buildBriefReportFromStore(app, store, ref, save),
-    dbPath: resolveTrailsDbPath({ rootDir }),
+  const rootDir = deriveRootDir(options?.rootDir);
+  const trailsDir = deriveTrailsDir({ rootDir });
+  return withCurrentTopoStore(app, rootDir, (store, ref, snapshot) => ({
+    app: buildBriefReportFromStore(app, store, ref, snapshot),
+    dbPath: deriveTrailsDbPath({ rootDir }),
     list: buildSurveyListFromStore(store, ref),
     lockExists: hasCommittedLock(trailsDir),
     lockPath: LOCK_PATH,
@@ -231,9 +226,9 @@ export const buildCurrentTopoBrief = (
   app: Topo,
   options?: { readonly rootDir?: string }
 ): BriefReport => {
-  const rootDir = resolveRootDir(options?.rootDir);
-  return withCurrentTopoStore(app, rootDir, (store, ref, save) =>
-    buildBriefReportFromStore(app, store, ref, save)
+  const rootDir = deriveRootDir(options?.rootDir);
+  return withCurrentTopoStore(app, rootDir, (store, ref, snapshot) =>
+    buildBriefReportFromStore(app, store, ref, snapshot)
   );
 };
 
@@ -241,7 +236,7 @@ export const buildCurrentTopoList = (
   app: Topo,
   options?: { readonly rootDir?: string }
 ): SurveyListReport => {
-  const rootDir = resolveRootDir(options?.rootDir);
+  const rootDir = deriveRootDir(options?.rootDir);
   return withCurrentTopoStore(app, rootDir, (store, ref) =>
     buildSurveyListFromStore(store, ref)
   );
@@ -256,9 +251,9 @@ export const buildCurrentGuideEntries = (
   readonly id: string;
   readonly kind: string;
 }[] => {
-  const rootDir = resolveRootDir(options?.rootDir);
+  const rootDir = deriveRootDir(options?.rootDir);
   return withCurrentTopoStore(app, rootDir, (store, ref) =>
-    store.trails.list({ save: ref }).map((trail) => ({
+    store.trails.list({ snapshot: ref }).map((trail) => ({
       description: trail.description ?? '(no description)',
       exampleCount: trail.exampleCount,
       id: trail.id,
@@ -271,18 +266,18 @@ export const buildCurrentTopoDetail = (
   app: Topo,
   id: string,
   options?: { readonly rootDir?: string }
-): CurrentProvisionDetail | CurrentTrailDetail | undefined => {
-  const rootDir = resolveRootDir(options?.rootDir);
+): CurrentResourceDetail | CurrentTrailDetail | undefined => {
+  const rootDir = deriveRootDir(options?.rootDir);
   return withCurrentTopoStore(app, rootDir, (store, ref) => {
-    const trail = store.trails.get(id, { save: ref });
+    const trail = store.trails.get(id, { snapshot: ref });
     if (trail !== undefined) {
       return buildTrailDetailFromStore(trail);
     }
 
-    const provision = store.provisions.get(id, { save: ref });
-    return provision === undefined
+    const resource = store.resources.get(id, { snapshot: ref });
+    return resource === undefined
       ? undefined
-      : buildProvisionDetailFromStore(provision);
+      : buildResourceDetailFromStore(resource);
   });
 };
 
@@ -290,9 +285,9 @@ export const verifyCurrentTopo = async (
   app: Topo,
   options?: { readonly rootDir?: string }
 ): Promise<Result<TopoVerifyReport, Error>> => {
-  const rootDir = resolveRootDir(options?.rootDir);
-  const committedLock = await readTrailheadLockData({
-    dir: resolveTrailsDir({ rootDir }),
+  const rootDir = deriveRootDir(options?.rootDir);
+  const committedLock = await readSurfaceLockData({
+    dir: deriveTrailsDir({ rootDir }),
   });
 
   if (committedLock === null) {
@@ -306,12 +301,14 @@ export const verifyCurrentTopo = async (
   const currentHash = withCurrentTopoStore(
     app,
     rootDir,
-    (store, ref) => store.exports.get(ref)?.trailheadHash
+    (store, ref) => store.exports.get(ref)?.surfaceHash
   );
 
   if (currentHash === undefined) {
     return Result.err(
-      new InternalError('No stored topo export found for the current topo save')
+      new InternalError(
+        'No stored topo export found for the current topo snapshot'
+      )
     );
   }
 

package/src/trails/topo-reports.ts

@@ -7,7 +7,7 @@ export interface BriefReport {
   readonly version: string;
   readonly contractVersion: string;
   readonly features: {
-    readonly provisions: boolean;
+    readonly resources: boolean;
     readonly outputSchemas: boolean;
     readonly examples: boolean;
     readonly detours: boolean;
@@ -15,7 +15,7 @@ export interface BriefReport {
   };
   readonly trails: number;
   readonly signals: number;
-  readonly provisions: number;
+  readonly resources: number;
 }
 
 export interface SurveyListReport {
@@ -26,12 +26,12 @@ export interface SurveyListReport {
     readonly kind: string;
     readonly safety: string;
   }[];
-  readonly provisionCount: number;
-  readonly provisions: readonly {
+  readonly resourceCount: number;
+  readonly resources: readonly {
     readonly description: string | null;
     readonly health: 'available' | 'none';
     readonly id: string;
-    readonly kind: 'provision';
+    readonly kind: 'resource';
     readonly lifetime: 'singleton';
     readonly usedBy: readonly string[];
   }[];
@@ -39,18 +39,21 @@ export interface SurveyListReport {
 
 export interface TrailDetailReport {
   readonly description: string | null;
-  readonly detours: Trail<unknown, unknown>['detours'] | null;
+  readonly detours:
+    | readonly { readonly on: string; readonly maxAttempts: number }[]
+    | null;
   readonly examples: readonly unknown[];
   readonly crosses: readonly string[];
   readonly id: string;
   readonly intent: 'read' | 'write' | 'destroy';
   readonly kind: string;
+  readonly pattern: string | null;
   readonly safety: string;
-  readonly provisions: readonly string[];
+  readonly resources: readonly string[];
 }
 
 const trailHas = (raw: Record<string, unknown>, key: string): boolean => {
-  if (key === 'examples') {
+  if (key === 'examples' || key === 'detours') {
     return Array.isArray(raw[key]) && (raw[key] as unknown[]).length > 0;
   }
   return Boolean(raw[key]);
@@ -62,7 +65,7 @@ const detectFeatures = (
   hasDetours: boolean;
   hasExamples: boolean;
   hasOutputSchemas: boolean;
-  hasProvisions: boolean;
+  hasResources: boolean;
 } => {
   const trails = [...app.trails.values()].map(
     (item) => item as unknown as Record<string, unknown>
@@ -71,16 +74,16 @@ const detectFeatures = (
     hasDetours: trails.some((r) => trailHas(r, 'detours')),
     hasExamples: trails.some((r) => trailHas(r, 'examples')),
     hasOutputSchemas: trails.some((r) => trailHas(r, 'output')),
-    hasProvisions: trails.some(
+    hasResources: trails.some(
       (r) =>
-        Array.isArray(r['provisions']) &&
-        (r['provisions'] as unknown[]).length > 0
+        Array.isArray(r['resources']) &&
+        (r['resources'] as unknown[]).length > 0
     ),
   };
 };
 
-export const generateBriefReport = (app: Topo): BriefReport => {
-  const { hasDetours, hasExamples, hasOutputSchemas, hasProvisions } =
+export const deriveBriefReport = (app: Topo): BriefReport => {
+  const { hasDetours, hasExamples, hasOutputSchemas, hasResources } =
     detectFeatures(app);
 
   return {
@@ -89,11 +92,11 @@ export const generateBriefReport = (app: Topo): BriefReport => {
       detours: hasDetours,
       examples: hasExamples,
       outputSchemas: hasOutputSchemas,
-      provisions: hasProvisions,
+      resources: hasResources,
       signals: app.signals.size > 0,
     },
     name: app.name,
-    provisions: app.provisions.size,
+    resources: app.resources.size,
     signals: app.signals.size,
     trails: app.trails.size,
     version: REPORT_VERSION,
@@ -115,16 +118,16 @@ const safetyLabel = (entry: {
   return '-';
 };
 
-const buildProvisionUsage = (
+const buildResourceUsage = (
   app: Topo
 ): ReadonlyMap<string, readonly string[]> => {
   const usage = new Map<string, string[]>();
 
   for (const trailDef of app.list()) {
-    for (const declaredProvision of trailDef.provisions) {
-      const users = usage.get(declaredProvision.id) ?? [];
+    for (const declaredResource of trailDef.resources) {
+      const users = usage.get(declaredResource.id) ?? [];
       users.push(trailDef.id);
-      usage.set(declaredProvision.id, users);
+      usage.set(declaredResource.id, users);
     }
   }
 
@@ -133,44 +136,41 @@ const buildProvisionUsage = (
   );
 };
 
-const provisionHealthStatus = (provision: {
+const resourceHealthStatus = (resource: {
   health?: unknown;
 }): 'available' | 'none' =>
-  provision.health === undefined ? 'none' : 'available';
+  resource.health === undefined ? 'none' : 'available';
 
-export const formatProvisionDetail = (
-  app: Topo,
-  provisionId: string
-): object => {
-  const item = app.getProvision(provisionId);
-  const usedBy = buildProvisionUsage(app).get(provisionId) ?? [];
+export const deriveResourceDetail = (app: Topo, resourceId: string): object => {
+  const item = app.getResource(resourceId);
+  const usedBy = buildResourceUsage(app).get(resourceId) ?? [];
 
   return {
     description: item?.description ?? null,
-    health: item ? provisionHealthStatus(item) : 'none',
-    id: provisionId,
-    kind: 'provision',
+    health: item ? resourceHealthStatus(item) : 'none',
+    id: resourceId,
+    kind: 'resource',
     lifetime: 'singleton',
     usedBy,
   };
 };
 
-const formatProvisionList = (app: Topo): SurveyListReport['provisions'] => {
-  const usage = buildProvisionUsage(app);
+const formatResourceList = (app: Topo): SurveyListReport['resources'] => {
+  const usage = buildResourceUsage(app);
   return app
-    .listProvisions()
-    .map((provision) => ({
-      description: provision.description ?? null,
-      health: provisionHealthStatus(provision),
-      id: provision.id,
-      kind: provision.kind,
+    .listResources()
+    .map((resource) => ({
+      description: resource.description ?? null,
+      health: resourceHealthStatus(resource),
+      id: resource.id,
+      kind: resource.kind,
       lifetime: 'singleton' as const,
-      usedBy: usage.get(provision.id) ?? [],
+      usedBy: usage.get(resource.id) ?? [],
     }))
     .toSorted((a, b) => a.id.localeCompare(b.id));
 };
 
-export const generateSurveyList = (app: Topo): SurveyListReport => {
+export const deriveSurveyList = (app: Topo): SurveyListReport => {
   const items = app.list();
   const entries = items.map((item) => {
     const safety = safetyLabel(
@@ -190,17 +190,17 @@ export const generateSurveyList = (app: Topo): SurveyListReport => {
     };
   });
 
-  const provisions = formatProvisionList(app);
+  const resources = formatResourceList(app);
 
   return {
     count: items.length,
     entries,
-    provisionCount: provisions.length,
-    provisions,
+    resourceCount: resources.length,
+    resources,
   };
 };
 
-export const generateTrailDetail = (
+export const deriveTrailDetail = (
   item: Trail<unknown, unknown>
 ): TrailDetailReport => {
   const safety = safetyLabel(
@@ -210,12 +210,19 @@ export const generateTrailDetail = (
   return {
     crosses: item.crosses.toSorted(),
     description: item.description ?? null,
-    detours: item.detours ?? null,
+    detours:
+      item.detours.length > 0
+        ? item.detours.map((d) => ({
+            maxAttempts: d.maxAttempts ?? 1,
+            on: d.on.name,
+          }))
+        : null,
     examples: item.examples ?? [],
     id: item.id,
     intent: item.intent,
     kind: item.kind,
-    provisions: item.provisions.map((provision) => provision.id).toSorted(),
+    pattern: item.pattern ?? null,
+    resources: item.resources.map((resource) => resource.id).toSorted(),
     safety,
   };
 };

package/src/trails/topo-show.ts

@@ -3,7 +3,6 @@ import { z } from 'zod';
 
 import { loadApp } from './load-app.js';
 import { buildCurrentTopoDetail } from './topo-read-support.js';
-import { DEFAULT_APP_MODULE } from './topo-support.js';
 
 const trailDetailOutput = z.object({
   crosses: z.array(z.string()),
@@ -13,15 +12,15 @@ const trailDetailOutput = z.object({
   id: z.string(),
   intent: z.enum(['read', 'write', 'destroy']),
   kind: z.string(),
-  provisions: z.array(z.string()),
+  resources: z.array(z.string()),
   safety: z.string(),
 });
 
-const provisionDetailOutput = z.object({
+const resourceDetailOutput = z.object({
   description: z.string().nullable(),
   health: z.enum(['available', 'none']),
   id: z.string(),
-  kind: z.literal('provision'),
+  kind: z.literal('resource'),
   lifetime: z.literal('singleton'),
   usedBy: z.array(z.string()),
 });
@@ -35,10 +34,10 @@ export const topoShowTrail = trail('topo.show', {
       return Result.ok(detail);
     }
     return Result.err(
-      new NotFoundError(`Trail or provision not found: ${input.id}`)
+      new NotFoundError(`Trail or resource not found: ${input.id}`)
     );
   },
-  description: 'Show detail for a current trail or provision',
+  description: 'Show detail for a current trail or resource',
   examples: [
     {
       input: { id: 'topo' },
@@ -46,13 +45,10 @@ export const topoShowTrail = trail('topo.show', {
     },
   ],
   input: z.object({
-    id: z.string().describe('Trail or provision ID to inspect'),
-    module: z
-      .string()
-      .default(DEFAULT_APP_MODULE)
-      .describe('Path to the app module'),
+    id: z.string().describe('Trail or resource ID to inspect'),
+    module: z.string().optional().describe('Path to the app module'),
     rootDir: z.string().optional().describe('Workspace root directory'),
   }),
   intent: 'read',
-  output: z.union([trailDetailOutput, provisionDetailOutput]),
+  output: z.union([trailDetailOutput, resourceDetailOutput]),
 });