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

package/CHANGELOG.md

@@ -1,5 +1,46 @@
 # @ontrails/config
 
+## 1.0.0-beta.16
+
+### Major Changes
+
+- 10eae9a: Migrate the Trails workspace to the documented `.trails/` layout: committed `.lock` files at the workspace root, ignored `cache/` for rebuildable derived data, ignored `state/` for mutable runtime state, and `.trails/config.local.{ts,js}` for local overrides. The default SQLite path is now `.trails/state/trails.db`. Workspace bootstrap creates only `cache/` and `state/` — the legacy `dev/` and `generated/` subdirectories are no longer created. Dev reset cleans both the new `.trails/state/` paths and legacy `.trails/trails.db*` and `.trails/dev/tracing.db*` paths for one cycle. Scaffold and workspace gitignores reflect the new layout.
+
+  Workspace bootstrap is now owned by a single canonical source in `@ontrails/core`. The package exposes `ensureTrailsWorkspace()`, `WORKSPACE_GITIGNORE_CONTENT`, and `WORKSPACE_GITIGNORE_LINES`. `@ontrails/config` no longer exports its own `ensureWorkspace` (consumers should import from `@ontrails/core`). `trails create` now writes `.trails/.gitignore` during scaffolding so a fresh-scaffolded project's initial commit includes the workspace gitignore (resolves TRL-703).
+
+### Patch Changes
+
+- 49c2e7d: Refresh published package README taxonomy to use adapter language instead of retired connector vocabulary.
+- Updated dependencies [73622ae]
+- Updated dependencies [6300f70]
+- Updated dependencies [d172013]
+- Updated dependencies [c3fc5c3]
+- Updated dependencies [20d7a5c]
+- Updated dependencies [be5fb46]
+- Updated dependencies [e898cc4]
+- Updated dependencies [3395234]
+- Updated dependencies [bcdc484]
+- Updated dependencies [331e3a9]
+- Updated dependencies [4399fdb]
+- Updated dependencies [4b8d13b]
+- Updated dependencies [112b9f2]
+- Updated dependencies [893025e]
+- Updated dependencies [eec5e9d]
+- Updated dependencies [ebd4434]
+- Updated dependencies [863d473]
+- Updated dependencies [344f2f7]
+- Updated dependencies [26f9ffd]
+- Updated dependencies [10eae9a]
+- Updated dependencies [22c6c06]
+  - @ontrails/core@1.0.0-beta.16
+
+## 1.0.0-beta.15
+
+### Patch Changes
+
+- Updated dependencies [4ad6b25]
+  - @ontrails/core@1.0.0-beta.15
+
 ## 1.0.0-beta.14
 
 ### Minor Changes

package/README.md

@@ -2,7 +2,7 @@
 
 Schema-derived configuration for Trails.
 
-The root package owns the connector-agnostic config declaration and resolution engine. Schemas define the contract; the provision and gate bind resolved values to the execution context.
+The root package owns the runtime-agnostic config declaration and resolution engine. Schemas define the contract, and `configResource` exposes resolved values to trail execution.
 
 ## The core pattern
 
@@ -24,7 +24,7 @@ export const config = defineConfig({
   base: {
     host: 'example.com',
   },
-  loadouts: {
+  profiles: {
     production: {
       debug: false,
       host: 'prod.example.com',
@@ -45,7 +45,7 @@ import { registerConfigState } from '@ontrails/config';
 
 const result = await config.resolve({
   cwd: process.cwd(),
-  loadout: process.env.TRAILS_ENV,
+  profile: process.env.TRAILS_ENV,
 });
 
 if (!result.isOk()) {
@@ -56,7 +56,7 @@ registerConfigState({
   resolved: result.unwrap(),
   schema: config.schema,
   base: config.base,
-  loadout: process.env.TRAILS_ENV,
+  profile: process.env.TRAILS_ENV,
   env: process.env,
 });
 ```
@@ -64,12 +64,12 @@ registerConfigState({
 ### 3. Access resolved config in trails
 
 ```typescript
-import { configProvision } from '@ontrails/config';
+import { configResource } from '@ontrails/config';
 
 export const getStatus = trail('status.get', {
-  provisions: [configProvision],
+  resources: [configResource],
   blaze: (_input, ctx) => {
-    const state = configProvision.from(ctx);
+    const state = configResource.from(ctx);
     return Result.ok({
       port: state.resolved.port,
       debug: state.resolved.debug,
@@ -83,11 +83,14 @@ export const getStatus = trail('status.get', {
 Config resolves through a deterministic priority order:
 
 ```text
-defaults (schema) → base → loadout → local → env
+defaults (schema) → base → profile → local → env
 ```
 
 Each layer overrides the previous. Environment variables always win.
 
+`appConfig()` discovers `*.config.toml`, `*.config.json`, `*.config.jsonc`, and
+`*.config.yaml` by default, plus dotfile equivalents when `dotfile: true`.
+
 ## Extensions
 
 ### `env()`
@@ -133,33 +136,22 @@ const schema = z.object({
 });
 ```
 
-## The provision
+## The resource
 
-The config provision manages resolved config lifecycle:
+The config resource manages resolved config lifecycle:
 
 ```typescript
-import { configProvision } from '@ontrails/config';
+import { configResource } from '@ontrails/config';
 
 export const myTrail = trail('my.trail', {
-  provisions: [configProvision],
+  resources: [configResource],
   blaze: (_input, ctx) => {
-    const state = configProvision.from(ctx);
+    const state = configResource.from(ctx);
     return Result.ok(state.resolved);
   },
 });
 ```
 
-## The gate
-
-The config gate reserves a slot in the execution context for per-trail config validation:
-
-```typescript
-import { configGate } from '@ontrails/config';
-
-export const app = topo('my-app', configModule);
-// Register configGate with your trailhead
-```
-
 ## Trail definitions
 
 ### `config.check`
@@ -172,7 +164,7 @@ Describe all fields in the schema — paths, types, defaults, env bindings, secr
 
 ### `config.explain`
 
-Show which source won for each config field — defaults, base, loadout, local, or env.
+Show which source won for each config field — defaults, base, profile, local, or env.
 
 ### `config.init`
 
@@ -180,13 +172,13 @@ Generate example config files in TOML, JSON, JSONC, or YAML. Optionally writes `
 
 ## Testing
 
-Trails that depend on `configProvision` auto-resolve with a mock when registered in the topo:
+Trails that depend on `configResource` auto-resolve with a mock when registered in the topo:
 
 ```typescript
 import { testAll } from '@ontrails/testing';
 
-const results = testAll(app);
-// configProvision.mock() is called automatically
+const results = testAll(graph);
+// configResource.mock() is called automatically
 ```
 
 For explicit test setup:

package/package.json

@@ -1,6 +1,14 @@
 {
   "name": "@ontrails/config",
-  "version": "1.0.0-beta.14",
+  "version": "1.0.0-beta.16",
+  "files": [
+    "src/**/*.ts",
+    "!src/**/__tests__/**",
+    "!src/**/*.test.ts",
+    "!src/**/*.test-d.ts",
+    "README.md",
+    "CHANGELOG.md"
+  ],
   "type": "module",
   "exports": {
     ".": "./src/index.ts",
@@ -14,7 +22,7 @@
     "clean": "rm -rf dist *.tsbuildinfo"
   },
   "peerDependencies": {
-    "@ontrails/core": "^1.0.0-beta.13",
+    "@ontrails/core": "^1.0.0-beta.15",
     "zod": "^4.3.5"
   }
 }

package/src/app-config.ts

@@ -9,10 +9,13 @@ import type { z } from 'zod';
 
 import type { CheckResult } from './doctor.js';
 import { checkConfig } from './doctor.js';
-import type { FieldDescription } from './describe.js';
-import { describeConfig } from './describe.js';
-import type { ExplainConfigOptions, ProvenanceEntry } from './explain.js';
-import { explainConfig } from './explain.js';
+import type { FieldDescription } from './derive-fields.js';
+import { deriveConfigFields } from './derive-fields.js';
+import type {
+  DeriveConfigProvenanceOptions,
+  ProvenanceEntry,
+} from './derive-provenance.js';
+import { deriveConfigProvenance } from './derive-provenance.js';
 import type { ConfigRef } from './ref.js';
 import { configRef } from './ref.js';
 
@@ -39,8 +42,8 @@ export interface ResolveOptions {
 }
 
 /** Options for the `explain()` method on AppConfig, excluding schema. */
-export type AppConfigExplainOptions = Omit<
-  ExplainConfigOptions<z.ZodType>,
+export type AppConfigDeriveProvenanceOptions = Omit<
+  DeriveConfigProvenanceOptions<z.ZodType>,
   'schema'
 >;
 
@@ -62,7 +65,9 @@ export interface AppConfig<T extends z.ZodType> {
   ): CheckResult;
 
   /** Show which source won for each config field. */
-  explain(options: AppConfigExplainOptions): readonly ProvenanceEntry[];
+  explain(
+    options: AppConfigDeriveProvenanceOptions
+  ): readonly ProvenanceEntry[];
 
   /** Create a lazy reference to a config field for use as a trail input default. */
   ref(fieldPath: string): ConfigRef;
@@ -72,7 +77,12 @@ export interface AppConfig<T extends z.ZodType> {
 // Default values
 // ---------------------------------------------------------------------------
 
-const DEFAULT_FORMATS: readonly ConfigFormat[] = ['toml', 'json', 'yaml'];
+const DEFAULT_FORMATS: readonly ConfigFormat[] = [
+  'toml',
+  'json',
+  'jsonc',
+  'yaml',
+];
 
 // ---------------------------------------------------------------------------
 // Internal helpers (defined before consumers — no-use-before-define)
@@ -225,7 +235,7 @@ const discoverConfigFile = async (
 };
 
 /** Resolve a config file — either from an explicit path or via discovery. */
-const resolveConfig = async <T extends z.ZodType>(
+const resolveAppConfigFile = async <T extends z.ZodType>(
   name: string,
   schema: T,
   formats: readonly ConfigFormat[],
@@ -292,16 +302,17 @@ export const appConfig = <T extends z.ZodType>(
   return {
     check: (values, checkOpts) => checkConfig(schema, values, checkOpts),
     describe: () =>
-      describeConfig(
+      deriveConfigFields(
         schema as unknown as z.ZodObject<Record<string, z.ZodType>>
       ),
     dotfile,
-    explain: (explainOpts) => explainConfig({ ...explainOpts, schema }),
+    explain: (explainOpts) =>
+      deriveConfigProvenance({ ...explainOpts, schema }),
     formats,
     name,
     ref: (fieldPath) => configRef(fieldPath),
     resolve: (resolveOptions?: ResolveOptions) =>
-      resolveConfig(name, schema, formats, dotfile, resolveOptions),
+      resolveAppConfigFile(name, schema, formats, dotfile, resolveOptions),
     schema,
   };
 };

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;
@@ -36,10 +36,13 @@ interface DefineConfigResolveOptions {
 // Local overrides discovery
 // ---------------------------------------------------------------------------
 
-const LOCAL_OVERRIDE_CANDIDATES = ['local.ts', 'local.js'] as const;
+const LOCAL_OVERRIDE_CANDIDATES = [
+  'config.local.ts',
+  'config.local.js',
+] as const;
 
 /**
- * Discover and synchronously import a `.trails/config/local.{ts,js}` file.
+ * Discover and synchronously import a `.trails/config.local.{ts,js}` file.
  *
  * Skipped when `TRAILS_ENV=test` for hermetic test environments.
  */
@@ -52,7 +55,7 @@ const discoverLocalOverrides = async (
   }
 
   for (const filename of LOCAL_OVERRIDE_CANDIDATES) {
-    const candidate = join(cwd, '.trails', 'config', filename);
+    const candidate = join(cwd, '.trails', filename);
     if (existsSync(candidate)) {
       const mod: Record<string, unknown> = await import(candidate);
       return (mod['default'] ?? mod) as Record<string, unknown>;
@@ -70,7 +73,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 +84,7 @@ const discoverLocalOverrides = async (
  *     debug: z.boolean().default(false),
  *   }),
  *   base: { port: 8080 },
- *   loadouts: {
+ *   profiles: {
  *     production: { debug: false },
  *     test: { debug: true, port: 0 },
  *   },
@@ -93,15 +96,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 +118,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/extensions.ts

@@ -34,7 +34,7 @@ export const secret = <T extends z.ZodType>(schema: T): T =>
  * standard key. We set `deprecated: true` so Zod-native tooling (schema
  * serializers, OpenAPI generators) recognises the field as deprecated, and store
  * the human-readable message under `deprecationMessage` for our own
- * `collectConfigMeta` / survey / explain trailheads.
+ * `collectConfigMeta` / survey / explain surfaces.
  *
  * Must be called BEFORE `.default()`, `.optional()`, or other transforms
  * so that the metadata lives on the inner type where `collectConfigMeta`

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,9 +35,8 @@ 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';
 export { configInit } from './trails/config-init.js';
-export { ensureWorkspace } from './workspace.js';