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

package/src/compose.ts

@@ -1,7 +1,7 @@
 /**
- * Config composition utilities for provisions.
+ * Config composition utilities for resources.
  *
- * Collects config schemas from provision declarations so they can be
+ * Collects config schemas from resource declarations so they can be
  * composed into a unified config structure via `defineConfig`.
  */
 
@@ -11,17 +11,14 @@ import type { z } from 'zod';
 // Types
 // ---------------------------------------------------------------------------
 
-/** A provision config schema entry extracted from a provision declaration. */
-export interface ProvisionConfigEntry {
-  readonly provisionId: string;
+/** A resource config schema entry extracted from a resource declaration. */
+export interface ResourceConfigEntry {
+  readonly resourceId: string;
   readonly schema: z.ZodType;
 }
 
-/** Backward-compatible alias while the migration is in flight. */
-export type ServiceConfigEntry = ProvisionConfigEntry;
-
-/** Minimal shape needed to extract config from a provision-like object. */
-interface ProvisionWithOptionalConfig {
+/** Minimal shape needed to extract config from a resource-like object. */
+interface ResourceWithOptionalConfig {
   readonly id: string;
   readonly config?: z.ZodType | undefined;
 }
@@ -31,22 +28,19 @@ interface ProvisionWithOptionalConfig {
 // ---------------------------------------------------------------------------
 
 /**
- * Collect config schemas from provisions that declare them.
+ * Collect config schemas from resources that declare them.
  *
- * Returns entries keyed by provision ID for composition into `defineConfig`.
- * Provisions without a `config` schema are excluded.
+ * Returns entries keyed by resource ID for composition into `defineConfig`.
+ * Resources without a `config` schema are excluded.
  */
-export const collectProvisionConfigs = (
-  provisions: readonly ProvisionWithOptionalConfig[]
-): ProvisionConfigEntry[] =>
-  provisions
+export const collectResourceConfigs = (
+  resources: readonly ResourceWithOptionalConfig[]
+): ResourceConfigEntry[] =>
+  resources
     .filter(
       (
         svc
-      ): svc is ProvisionWithOptionalConfig & { readonly config: z.ZodType } =>
+      ): svc is ResourceWithOptionalConfig & { readonly config: z.ZodType } =>
         svc.config !== undefined
     )
-    .map((svc) => ({ provisionId: svc.id, schema: svc.config }));
-
-/** Backward-compatible alias while the migration is in flight. */
-export const collectServiceConfigs = collectProvisionConfigs;
+    .map((svc) => ({ resourceId: svc.id, schema: svc.config }));

package/src/{config-provision.ts → config-resource.ts}

@@ -1,17 +1,17 @@
 /**
- * Config provision — manages resolved config lifecycle.
+ * Config resource — manages resolved config lifecycle.
  *
  * The config is resolved during bootstrap (two-phase init per ADR-010)
- * and registered via `registerConfigState`. This provision reads from the
- * global registry so trails can access it through `configProvision.from(ctx)`.
+ * and registered via `registerConfigState`. This resource reads from the
+ * global registry so trails can access it through `configResource.from(ctx)`.
  */
-import { InternalError, Result, provision } from '@ontrails/core';
+import { InternalError, Result, resource } from '@ontrails/core';
 import { z } from 'zod';
 
 import type { ConfigState } from './registry.js';
 import { getConfigState } from './registry.js';
 
-export const configProvision = provision<ConfigState>('config', {
+export const configResource = resource<ConfigState>('config', {
   create: () => {
     const state = getConfigState();
     if (state === undefined) {

package/src/define-config.ts

@@ -1,6 +1,6 @@
 /**
  * Trails-specific config wrapper — `appConfig('trails', ...)` with
- * framework conventions for loadout selection and local overrides.
+ * framework conventions for profile selection and local overrides.
  */
 
 import { existsSync } from 'node:fs';
@@ -9,7 +9,7 @@ import { join } from 'node:path';
 import type { z } from 'zod';
 
 import { appConfig } from './app-config.js';
-import { resolveConfig } from './resolve.js';
+import { deriveConfig } from './resolve.js';
 
 // ---------------------------------------------------------------------------
 // Types
@@ -19,14 +19,14 @@ import { resolveConfig } from './resolve.js';
 export interface DefineConfigOptions<T extends z.ZodType> {
   readonly schema: T;
   readonly base?: Partial<z.infer<T>>;
-  readonly loadouts?: Record<string, Partial<z.infer<T>>>;
+  readonly profiles?: Record<string, Partial<z.infer<T>>>;
   /** When true, fall back to `NODE_ENV` when `TRAILS_ENV` is unset. */
   readonly envFromNodeEnv?: boolean;
 }
 
 /** Options passed to `resolve()` on a defined config. */
 interface DefineConfigResolveOptions {
-  readonly loadout?: string;
+  readonly profile?: string;
   readonly env?: Record<string, string | undefined>;
   /** Working directory for local overrides discovery. Defaults to `process.cwd()`. */
   readonly cwd?: string;
@@ -70,7 +70,7 @@ const discoverLocalOverrides = async (
  * Define Trails app config.
  *
  * This is `appConfig('trails', ...)` with the framework's own conventions:
- * `TRAILS_ENV` selects the loadout. When `envFromNodeEnv` is true,
+ * `TRAILS_ENV` selects the profile. When `envFromNodeEnv` is true,
  * `NODE_ENV` is used as a fallback when `TRAILS_ENV` is unset.
  *
  * @example
@@ -81,7 +81,7 @@ const discoverLocalOverrides = async (
  *     debug: z.boolean().default(false),
  *   }),
  *   base: { port: 8080 },
- *   loadouts: {
+ *   profiles: {
  *     production: { debug: false },
  *     test: { debug: true, port: 0 },
  *   },
@@ -93,15 +93,12 @@ const discoverLocalOverrides = async (
 export const defineConfig = <T extends z.ZodType>(
   options: DefineConfigOptions<T>
 ) => {
-  const config = appConfig('trails', {
-    formats: ['toml', 'json'],
-    schema: options.schema,
-  });
+  const config = appConfig('trails', { schema: options.schema });
 
   return {
     ...config,
     base: options.base,
-    loadouts: options.loadouts,
+    profiles: options.profiles,
     resolve: async (resolveOpts?: DefineConfigResolveOptions) => {
       const envRecord = {
         ...(resolveOpts?.env ?? process.env),
@@ -118,14 +115,14 @@ export const defineConfig = <T extends z.ZodType>(
       const cwd = resolveOpts?.cwd ?? process.cwd();
       const localOverrides = await discoverLocalOverrides(cwd, envRecord);
 
-      return resolveConfig({
+      return deriveConfig({
         base: options.base as Record<string, unknown> | undefined,
         env: envRecord,
-        loadout: resolveOpts?.loadout ?? envRecord['TRAILS_ENV'],
-        loadouts: options.loadouts as
+        localOverrides,
+        profile: resolveOpts?.profile ?? envRecord['TRAILS_ENV'],
+        profiles: options.profiles as
           | Record<string, Record<string, unknown>>
           | undefined,
-        localOverrides,
         schema: options.schema,
       });
     },

package/src/{generate → derive}/env.ts

@@ -15,7 +15,7 @@ import {
   formatValue,
   getDefault,
   getDescription,
-  resolveFieldByPath,
+  deriveFieldByPath,
   unwrap,
   zodTypeName,
   zodTypeToJsonSchema,
@@ -76,7 +76,7 @@ const collectEnvEntries = (
     if (!fieldMeta.env) {
       continue;
     }
-    const fieldSchema = resolveFieldByPath(schema, path);
+    const fieldSchema = deriveFieldByPath(schema, path);
     if (!fieldSchema) {
       continue;
     }
@@ -96,7 +96,7 @@ const collectEnvEntries = (
  * Lists each env var with its type, default, and whether it is a secret.
  * Returns an empty string when no env bindings are present.
  */
-export const generateEnvExample = (
+export const deriveConfigEnvExample = (
   schema: z.ZodObject<Record<string, z.ZodType>>
 ): string => {
   const entries = collectEnvEntries(schema, collectConfigMeta(schema));

package/src/{generate → derive}/example.ts

@@ -216,7 +216,7 @@ const formatters: Record<
  *
  * Includes descriptions as comments, defaults shown, deprecated fields annotated.
  */
-export const generateExample = (
+export const deriveConfigExample = (
   schema: z.ZodObject<Record<string, z.ZodType>>,
   format: ExampleFormat
 ): string => formatters[format](schema);

package/src/{generate → derive}/helpers.ts

@@ -86,7 +86,7 @@ export const getObjectShape = (
 };
 
 /** Resolve a dot-separated path to the field schema within an object. */
-export const resolveFieldByPath = (
+export const deriveFieldByPath = (
   schema: z.ZodObject<Record<string, z.ZodType>>,
   path: string
 ): z.ZodType | undefined => {

package/src/derive/index.ts

@@ -0,0 +1,3 @@
+export { deriveConfigEnvExample } from './env.js';
+export { deriveConfigExample } from './example.js';
+export { deriveConfigJsonSchema } from './json-schema.js';

package/src/{generate → derive}/json-schema.ts

@@ -112,7 +112,7 @@ const buildSchemaProperties = (
  * Includes descriptions, defaults, deprecated annotations, and constraints.
  * Produces JSON Schema Draft 2020-12.
  */
-export const generateJsonSchema = (
+export const deriveConfigJsonSchema = (
   schema: z.ZodObject<Record<string, z.ZodType>>,
   options?: { readonly description?: string; readonly title?: string }
 ): Record<string, unknown> => {

package/src/{describe.ts → derive-fields.ts}

@@ -228,7 +228,7 @@ const walkShapeLevel = (
  *
  * Returns a structured catalog suitable for CLI rendering or agent inspection.
  */
-export const describeConfig = (
+export const deriveConfigFields = (
   schema: z.ZodObject<Record<string, z.ZodType>>
 ): readonly FieldDescription[] => {
   const configMeta = collectConfigMeta(schema);

package/src/{explain.ts → derive-provenance.ts}

@@ -18,15 +18,15 @@ import { getAtPath, isZodObject, unwrapToBase, zodDef } from './zod-utils.js';
 export interface ProvenanceEntry {
   readonly path: string;
   readonly value: unknown;
-  readonly source: 'default' | 'base' | 'loadout' | 'local' | 'env';
+  readonly source: 'default' | 'base' | 'profile' | 'local' | 'env';
   readonly redacted: boolean;
 }
 
 /** Options for explaining config provenance. */
-export interface ExplainConfigOptions<T extends z.ZodType> {
+export interface DeriveConfigProvenanceOptions<T extends z.ZodType> {
   readonly schema: T;
   readonly base?: Record<string, unknown>;
-  readonly loadout?: Record<string, unknown>;
+  readonly profile?: Record<string, unknown>;
   readonly local?: Record<string, unknown>;
   readonly env?: Record<string, string | undefined>;
   readonly resolved: Record<string, unknown>;
@@ -135,8 +135,8 @@ const collectLeafPaths = (schema: z.ZodType, prefix: string): string[] => {
  * Used for debugging — answers "where did this value come from?"
  *
  */
-export const explainConfig = <T extends z.ZodType>(
-  options: ExplainConfigOptions<T>
+export const deriveConfigProvenance = <T extends z.ZodType>(
+  options: DeriveConfigProvenanceOptions<T>
 ): readonly ProvenanceEntry[] => {
   const objSchema = options.schema as unknown as z.ZodObject<
     Record<string, z.ZodType>
@@ -146,7 +146,7 @@ export const explainConfig = <T extends z.ZodType>(
 
   const sources: readonly SourceEntry[] = [
     ['local', options.local],
-    ['loadout', options.loadout],
+    ['profile', options.profile],
     ['base', options.base],
   ];
 

package/src/index.ts

@@ -1,20 +1,15 @@
 export {
   appConfig,
   type AppConfig,
-  type AppConfigExplainOptions,
+  type AppConfigDeriveProvenanceOptions,
   type AppConfigOptions,
   type ConfigFormat,
   type ResolveOptions,
 } from './app-config.js';
 export { collectConfigMeta } from './collect.js';
-export {
-  collectProvisionConfigs,
-  collectServiceConfigs,
-  type ProvisionConfigEntry,
-  type ServiceConfigEntry,
-} from './compose.js';
+export { collectResourceConfigs, type ResourceConfigEntry } from './compose.js';
 export { defineConfig, type DefineConfigOptions } from './define-config.js';
-export { describeConfig, type FieldDescription } from './describe.js';
+export { deriveConfigFields, type FieldDescription } from './derive-fields.js';
 export {
   checkConfig,
   type CheckResult,
@@ -22,17 +17,16 @@ export {
 } from './doctor.js';
 export { env, secret, deprecated, type ConfigFieldMeta } from './extensions.js';
 export {
-  explainConfig,
-  type ExplainConfigOptions,
+  deriveConfigProvenance,
+  type DeriveConfigProvenanceOptions,
   type ProvenanceEntry,
-} from './explain.js';
+} from './derive-provenance.js';
 export {
-  generateEnvExample,
-  generateExample,
-  generateJsonSchema,
-} from './generate/index.js';
-export { configGate } from './config-gate.js';
-export { configProvision } from './config-provision.js';
+  deriveConfigEnvExample,
+  deriveConfigExample,
+  deriveConfigJsonSchema,
+} from './derive/index.js';
+export { configResource } from './config-resource.js';
 export {
   clearConfigState,
   type ConfigState,
@@ -41,7 +35,7 @@ export {
 } from './registry.js';
 export { deepMerge } from './merge.js';
 export { configRef, isConfigRef, type ConfigRef } from './ref.js';
-export { resolveConfig, type ResolveConfigOptions } from './resolve.js';
+export { deriveConfig, type DeriveConfigOptions } from './resolve.js';
 export { configCheck } from './trails/config-check.js';
 export { configDescribe } from './trails/config-describe.js';
 export { configExplain } from './trails/config-explain.js';

package/src/registry.ts

@@ -2,7 +2,7 @@
  * Module-level config state registry.
  *
  * Config is resolved once at bootstrap (two-phase init per ADR-010) and
- * registered here so `configProvision` can expose it to trailheads. This is
+ * registered here so `configResource` can expose it to trailheads. This is
  * a process-level singleton — config resolution is inherently global.
  */
 import type { z } from 'zod';
@@ -12,7 +12,7 @@ export interface ConfigState {
   readonly schema: z.ZodObject<Record<string, z.ZodType>>;
   readonly resolved: Record<string, unknown>;
   readonly base?: Record<string, unknown>;
-  readonly loadout?: Record<string, unknown>;
+  readonly profile?: Record<string, unknown>;
   readonly local?: Record<string, unknown>;
   readonly env?: Record<string, string | undefined>;
 }

package/src/resolve.ts

@@ -1,6 +1,6 @@
 /**
  * Config resolution engine — merges config from multiple sources through
- * a deterministic stack: defaults → base → loadout → local → env.
+ * a deterministic stack: defaults → base → profile → local → env.
  */
 
 import type { z } from 'zod';
@@ -16,11 +16,11 @@ import { zodDef } from './zod-utils.js';
 // ---------------------------------------------------------------------------
 
 /** Options for resolving config through the full stack. */
-export interface ResolveConfigOptions<T extends z.ZodType> {
+export interface DeriveConfigOptions<T extends z.ZodType> {
   readonly schema: T;
   readonly base?: Record<string, unknown> | undefined;
-  readonly loadouts?: Record<string, Record<string, unknown>> | undefined;
-  readonly loadout?: string | undefined;
+  readonly profiles?: Record<string, Record<string, unknown>> | undefined;
+  readonly profile?: string | undefined;
   readonly localOverrides?: Record<string, unknown> | undefined;
   readonly env?: Record<string, string | undefined> | undefined;
 }
@@ -219,11 +219,11 @@ const applyEnvOverrides = (
 // Merge pipeline
 // ---------------------------------------------------------------------------
 
-/** Apply the layered merge: base → loadout → local overrides. */
+/** Apply the layered merge: base → profile → local overrides. */
 const mergeLayers = (
   base: Record<string, unknown> | undefined,
-  loadouts: Record<string, Record<string, unknown>> | undefined,
-  loadout: string | undefined,
+  profiles: Record<string, Record<string, unknown>> | undefined,
+  profile: string | undefined,
   localOverrides: Record<string, unknown> | undefined
 ): Record<string, unknown> => {
   let merged: Record<string, unknown> = {};
@@ -231,7 +231,7 @@ const mergeLayers = (
     merged = deepMerge(merged, base);
   }
 
-  const selected = loadout && loadouts ? loadouts[loadout] : undefined;
+  const selected = profile && profiles ? profiles[profile] : undefined;
   if (selected) {
     merged = deepMerge(merged, selected);
   }
@@ -253,16 +253,16 @@ const formatValidationError = (
 // ---------------------------------------------------------------------------
 
 /**
- * Resolve config through the full stack: defaults → base → loadout → local → env.
+ * Derive config through the full stack: defaults → base → profile → local → env.
  * Returns `Result.ok` with the validated config, or `Result.err` on validation failure.
  */
-export const resolveConfig = <T extends z.ZodType>(
-  options: ResolveConfigOptions<T>
+export const deriveConfig = <T extends z.ZodType>(
+  options: DeriveConfigOptions<T>
 ): Result<z.infer<T>, Error> => {
   let merged = mergeLayers(
     options.base,
-    options.loadouts,
-    options.loadout,
+    options.profiles,
+    options.profile,
     options.localOverrides
   );
 

package/src/trails/config-check.ts

@@ -7,7 +7,7 @@
 import { Result, trail } from '@ontrails/core';
 import { z } from 'zod';
 
-import { configProvision } from '../config-provision.js';
+import { configResource } from '../config-resource.js';
 import { checkConfig } from '../doctor.js';
 import { deepMerge } from '../merge.js';
 
@@ -33,7 +33,7 @@ const mergeValues = (
 
 export const configCheck = trail('config.check', {
   blaze: (input, ctx) => {
-    const state = configProvision.from(ctx);
+    const state = configResource.from(ctx);
     const effective = mergeValues(state.resolved, input.values);
     const checked = checkConfig(state.schema, effective);
     return Result.ok({
@@ -56,5 +56,5 @@ export const configCheck = trail('config.check', {
   intent: 'read',
   meta: { category: 'infrastructure' },
   output: outputSchema,
-  provisions: [configProvision],
+  resources: [configResource],
 });

package/src/trails/config-describe.ts

@@ -7,8 +7,8 @@
 import { Result, trail } from '@ontrails/core';
 import { z } from 'zod';
 
-import { configProvision } from '../config-provision.js';
-import { describeConfig } from '../describe.js';
+import { configResource } from '../config-resource.js';
+import { deriveConfigFields } from '../derive-fields.js';
 
 const fieldSchema = z.object({
   deprecated: z.string().optional(),
@@ -26,8 +26,8 @@ const outputSchema = z.object({
 
 export const configDescribe = trail('config.describe', {
   blaze: (_input, ctx) => {
-    const state = configProvision.from(ctx);
-    const fields = describeConfig(state.schema);
+    const state = configResource.from(ctx);
+    const fields = deriveConfigFields(state.schema);
     return Result.ok({ fields: [...fields] });
   },
   examples: [
@@ -40,5 +40,5 @@ export const configDescribe = trail('config.describe', {
   intent: 'read',
   meta: { category: 'infrastructure' },
   output: outputSchema,
-  provisions: [configProvision],
+  resources: [configResource],
 });

package/src/trails/config-explain.ts

@@ -7,9 +7,9 @@
 import { Result, trail } from '@ontrails/core';
 import { z } from 'zod';
 
-import { configProvision } from '../config-provision.js';
-import type { ExplainConfigOptions } from '../explain.js';
-import { explainConfig } from '../explain.js';
+import { configResource } from '../config-resource.js';
+import type { DeriveConfigProvenanceOptions } from '../derive-provenance.js';
+import { deriveConfigProvenance } from '../derive-provenance.js';
 import type { ConfigState } from '../registry.js';
 
 const provenanceEntrySchema = z.object({
@@ -34,11 +34,11 @@ const filterByPath = (
       )
     : entries;
 
-/** Build ExplainConfigOptions from ConfigState, omitting undefined source overrides. */
+/** Build DeriveConfigProvenanceOptions from ConfigState, omitting undefined source overrides. */
 const toExplainOptions = (
   state: ConfigState
-): ExplainConfigOptions<typeof state.schema> => {
-  const base: ExplainConfigOptions<typeof state.schema> = {
+): DeriveConfigProvenanceOptions<typeof state.schema> => {
+  const base: DeriveConfigProvenanceOptions<typeof state.schema> = {
     resolved: state.resolved,
     schema: state.schema,
   };
@@ -51,14 +51,14 @@ const toExplainOptions = (
 /** Enrich explain options with env and source overrides from state. */
 const enrichOptions = (
   state: ConfigState,
-  options: ExplainConfigOptions<typeof state.schema>
-): ExplainConfigOptions<typeof state.schema> => {
+  options: DeriveConfigProvenanceOptions<typeof state.schema>
+): DeriveConfigProvenanceOptions<typeof state.schema> => {
   let enriched = options;
   if (state.env) {
     enriched = { ...enriched, env: state.env };
   }
-  if (state.loadout) {
-    enriched = { ...enriched, loadout: state.loadout };
+  if (state.profile) {
+    enriched = { ...enriched, profile: state.profile };
   }
   if (state.local) {
     enriched = { ...enriched, local: state.local };
@@ -68,9 +68,9 @@ const enrichOptions = (
 
 export const configExplain = trail('config.explain', {
   blaze: (input, ctx) => {
-    const state = configProvision.from(ctx);
+    const state = configResource.from(ctx);
     const options = enrichOptions(state, toExplainOptions(state));
-    const entries = explainConfig(options);
+    const entries = deriveConfigProvenance(options);
     const filtered = filterByPath(entries, input.path);
     return Result.ok({ entries: [...filtered] });
   },
@@ -89,5 +89,5 @@ export const configExplain = trail('config.explain', {
   intent: 'read',
   meta: { category: 'infrastructure' },
   output: outputSchema,
-  provisions: [configProvision],
+  resources: [configResource],
 });

package/src/trails/config-init.ts

@@ -14,12 +14,12 @@ import { Result, trail } from '@ontrails/core';
 import type { z } from 'zod';
 import { z as zod } from 'zod';
 
-import { configProvision } from '../config-provision.js';
+import { configResource } from '../config-resource.js';
 import {
-  generateEnvExample,
-  generateExample,
-  generateJsonSchema,
-} from '../generate/index.js';
+  deriveConfigEnvExample,
+  deriveConfigExample,
+  deriveConfigJsonSchema,
+} from '../derive/index.js';
 
 const formatEnum = zod.enum(['toml', 'json', 'jsonc', 'yaml']);
 
@@ -34,13 +34,13 @@ const collectArtifacts = (
   schema: z.ZodObject<Record<string, z.ZodType>>
 ): [string, string][] => {
   const artifacts: [string, string][] = [];
-  const envContent = generateEnvExample(schema);
+  const envContent = deriveConfigEnvExample(schema);
   if (envContent.length > 0) {
     artifacts.push(['.env.example', envContent]);
   }
   artifacts.push([
     '.schema.json',
-    JSON.stringify(generateJsonSchema(schema), null, 2),
+    JSON.stringify(deriveConfigJsonSchema(schema), null, 2),
   ]);
   return artifacts;
 };
@@ -63,9 +63,9 @@ const writeArtifacts = async (
 
 export const configInit = trail('config.init', {
   blaze: async (input, ctx) => {
-    const state = configProvision.from(ctx);
+    const state = configResource.from(ctx);
     const schema = state.schema as z.ZodObject<Record<string, z.ZodType>>;
-    const content = generateExample(schema, input.format);
+    const content = deriveConfigExample(schema, input.format);
 
     if (input.dir) {
       const writtenFiles = await writeArtifacts(input.dir, schema);
@@ -92,5 +92,5 @@ export const configInit = trail('config.init', {
   intent: 'write',
   meta: { category: 'infrastructure' },
   output: outputSchema,
-  provisions: [configProvision],
+  resources: [configResource],
 });

package/tsconfig.tests.json

@@ -0,0 +1,10 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "noEmit": true,
+    "rootDir": "./src",
+    "types": ["bun"]
+  },
+  "include": ["src/**/*.test.ts", "src/__tests__/**/*.ts"],
+  "exclude": []
+}

package/tsconfig.tsbuildinfo

@@ -1 +1 @@
-{"root":["./src/app-config.ts","./src/collect.ts","./src/compose.ts","./src/config-gate.ts","./src/config-provision.ts","./src/define-config.ts","./src/describe.ts","./src/doctor.ts","./src/explain.ts","./src/extensions.ts","./src/index.ts","./src/merge.ts","./src/ref.ts","./src/registry.ts","./src/resolve.ts","./src/secret-heuristics.ts","./src/workspace.ts","./src/zod-utils.ts","./src/generate/env.ts","./src/generate/example.ts","./src/generate/helpers.ts","./src/generate/index.ts","./src/generate/json-schema.ts","./src/trails/config-check.ts","./src/trails/config-describe.ts","./src/trails/config-explain.ts","./src/trails/config-init.ts"],"version":"5.9.3"}
+{"root":["./src/app-config.ts","./src/collect.ts","./src/compose.ts","./src/config-resource.ts","./src/define-config.ts","./src/derive-fields.ts","./src/derive-provenance.ts","./src/doctor.ts","./src/extensions.ts","./src/index.ts","./src/merge.ts","./src/ref.ts","./src/registry.ts","./src/resolve.ts","./src/secret-heuristics.ts","./src/workspace.ts","./src/zod-utils.ts","./src/derive/env.ts","./src/derive/example.ts","./src/derive/helpers.ts","./src/derive/index.ts","./src/derive/json-schema.ts","./src/trails/config-check.ts","./src/trails/config-describe.ts","./src/trails/config-explain.ts","./src/trails/config-init.ts"],"version":"5.9.3"}

package/dist/config-gate.d.ts

@@ -1,11 +0,0 @@
-/**
- * Config gate — attaches resolved config to the execution context.
- *
- * For v1, the gate is a pass-through: config resolution happens at
- * bootstrap time and the provision pipeline (TRL-91) injects the resolved
- * config before any trail runs. The gate reserves a named slot so future
- * versions can add per-trail config overrides or validation.
- */
-import type { Gate } from '@ontrails/core';
-export declare const configGate: Gate;
-//# sourceMappingURL=config-gate.d.ts.map

package/dist/config-gate.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"config-gate.d.ts","sourceRoot":"","sources":["../src/config-gate.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,gBAAgB,CAAC;AAE3C,eAAO,MAAM,UAAU,EAAE,IAIxB,CAAC"}

package/dist/config-gate.js

@@ -1,6 +0,0 @@
-export const configGate = {
-    description: 'Ensures resolved config is available in the execution context',
-    name: 'config',
-    wrap: (_trail, impl) => (input, ctx) => impl(input, ctx),
-};
-//# sourceMappingURL=config-gate.js.map

package/dist/config-gate.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"config-gate.js","sourceRoot":"","sources":["../src/config-gate.ts"],"names":[],"mappings":"AAUA,MAAM,CAAC,MAAM,UAAU,GAAS;IAC9B,WAAW,EAAE,+DAA+D;IAC5E,IAAI,EAAE,QAAQ;IACd,IAAI,EAAE,CAAC,MAAM,EAAE,IAAI,EAAE,EAAE,CAAC,CAAC,KAAK,EAAE,GAAG,EAAE,EAAE,CAAC,IAAI,CAAC,KAAK,EAAE,GAAG,CAAC;CACzD,CAAC"}