@malloydata/malloy 0.0.391 → 0.0.392

package/dist/api/asynchronous.js

@@ -147,7 +147,6 @@ async function fetchNeeds(needs, fetchers) {
 async function compileModel(request, fetchers) {
     const timer = new timing_1.Timer('compile_model');
     const state = Core.newCompileModelState(request);
-    // eslint-disable-next-line no-constant-condition
     while (true) {
         const result = Core.statedCompileModel(state);
         timer.incorporate(result.timing_info);
@@ -162,7 +161,6 @@ async function compileModel(request, fetchers) {
 async function compileSource(request, fetchers) {
     const timer = new timing_1.Timer('compile_source');
     const state = Core.newCompileSourceState(request);
-    // eslint-disable-next-line no-constant-condition
     while (true) {
         const result = Core.statedCompileSource(state, request.name);
         timer.incorporate(result.timing_info);
@@ -177,7 +175,6 @@ async function compileSource(request, fetchers) {
 async function compileQuery(request, fetchers) {
     const timer = new timing_1.Timer('compile_query');
     const state = Core.newCompileQueryState(request);
-    // eslint-disable-next-line no-constant-condition
     while (true) {
         const result = Core.statedCompileQuery(state);
         timer.incorporate(result.timing_info);

package/dist/api/foundation/compile.d.ts

@@ -121,7 +121,7 @@ export declare class Malloy {
      * instead of looping forever, but the fix is to correct the dialect.
      */
     static safelyFetchTableSchema(connection: InfoConnection, toFetch: Record<string, string>, opts: FetchSchemaOptions): Promise<{
-        schemas: Record<string, import("../../model").TableSourceDef>;
+        schemas: Record<string, import("../..").TableSourceDef>;
         errors: Record<string, string>;
     }>;
     /**

package/dist/api/foundation/config.d.ts

@@ -100,23 +100,95 @@ export declare class Manifest {
  * `urlReader.readURL()` / `JSON.parse()` and pass the POJO, or use the
  * sync string form after reading the file.
  */
+/**
+ * Filesystem context for a `MalloyConfig`: where the config file lives
+ * (`configURL`) and where the project root is (`rootDirectory`).
+ *
+ * Both are URL-shaped strings (e.g. `'file:///path/to/config.json'`).
+ * Hosts in Node convert their paths to file URLs (`url.pathToFileURL(path)
+ * .toString()`); browser hosts pass `https://...` or whatever scheme they
+ * serve from. Foundation never reaches for `process.cwd` — that decision
+ * lives in the host.
+ *
+ *   - `configURL` — anchor for `manifestPath` and `givensPath` resolution.
+ *     Set by `discoverConfig` to the URL of the matched config file. POJO
+ *     callers pass it directly when their config carries any path setting.
+ *   - `rootDirectory` — project root. Consumed by connection-property
+ *     defaults via the `{config: 'rootDirectory'}` overlay-reference shape
+ *     (e.g. DuckDB's `databasePath` default). Set by `discoverConfig` to
+ *     the ceiling of the discovery range; POJO callers pass it when they
+ *     need a project-rooted anchor.
+ */
+export type FilesystemContext = {
+    configURL?: string;
+    rootDirectory?: string;
+};
+/**
+ * Second-arg options for `MalloyConfig`. Combines the filesystem context
+ * with non-`config` overlays. The `config` slot in `overlays` is reserved
+ * — pass `configURL` / `rootDirectory` directly instead. A reserved-slot
+ * collision is warned and dropped, not silently merged.
+ */
+export interface MalloyConfigOptions extends FilesystemContext {
+    overlays?: ConfigOverlays;
+}
 export declare class MalloyConfig {
     readonly virtualMap?: VirtualMap;
+    /** URL-shaped string of the config file, or undefined if not supplied. */
+    readonly configURL?: string;
+    /** URL-shaped string of the project root, or undefined if not supplied. */
+    readonly rootDirectory?: string;
     readonly manifestPath?: string;
     /**
-     * Resolved URL of the manifest file (`malloy-manifest.json`), if a
-     * `configURL` was provided in the `config` overlay. Computed once in the
-     * constructor from `manifestPath` (default `'MANIFESTS'`) joined to
-     * `configURL`. Stays `undefined` for callers that didn't supply a
-     * `configURL` — Runtime treats that as "no auto-read."
+     * Resolved URL string of the manifest file (`malloy-manifest.json`), if a
+     * `configURL` was supplied. Computed once in the constructor from
+     * `manifestPath` (default `'MANIFESTS'`) joined to `configURL`. Stays
+     * `undefined` when no `configURL` is available — Runtime treats that as
+     * "no auto-read."
+     */
+    readonly manifestURL?: string;
+    readonly givensPath?: string;
+    /**
+     * Resolved URL string of the givens-values JSON file, if `givensPath`
+     * was set and a `configURL` was supplied. Resolved against `configURL`
+     * so relative paths in the project's `malloy-config.json` work the same
+     * way `manifestPath` does. Stays `undefined` if `givensPath` was not
+     * configured; Runtime treats that as "no per-runtime givens layer."
+     */
+    readonly givensURL?: string;
+    /**
+     * Surface names of givens that the runtime locks. Locked givens cannot
+     * be overridden via per-query supply (`.run({givens: {X: ...}})` for a
+     * locked X throws at API entry) and are filtered out of `Model.givens`
+     * / `PreparedQuery.givens` introspection so UIs don't render editors
+     * for them. Security primitive — multi-tenant deployments lock the
+     * tenant identifier so a downstream endpoint that accidentally accepts
+     * caller-controlled overrides can't leak across tenants.
+     *
+     * Validation that every locked name has a resolved value (file +
+     * constructor) happens lazily at the first compile that needs givens,
+     * since the `givensURL` file read is async.
      */
-    readonly manifestURL?: URL;
+    readonly finalizeGivens?: ReadonlyArray<string>;
     readonly log: readonly LogMessage[];
     private _connections;
     private readonly _managedLookup;
     private readonly _overlays;
-    constructor(source: string);
-    constructor(pojo: object, overlays?: ConfigOverlays);
+    /**
+     * @deprecated Pass `MalloyConfigOptions` (`{configURL, rootDirectory,
+     * overlays}`) instead of a raw `ConfigOverlays` dict. The old shape is
+     * detected at runtime and adapted automatically; remove the
+     * `contextOverlay({...})` wrapping when convenient.
+     */
+    constructor(source: string, overlays: ConfigOverlays);
+    /** Build a `MalloyConfig` from a JSON config string. */
+    constructor(source: string, options?: MalloyConfigOptions);
+    /**
+     * @deprecated See the source-string overload's deprecation note.
+     */
+    constructor(pojo: object, overlays: ConfigOverlays);
+    /** Build a `MalloyConfig` from a parsed POJO. */
+    constructor(pojo: object, options?: MalloyConfigOptions);
     /**
      * The live `LookupConnection` consumed by Runtime. Stable until
      * `wrapConnections()` is called; after that, returns the wrapped lookup.

package/dist/api/foundation/config.js

@@ -109,50 +109,8 @@ class Manifest {
     }
 }
 exports.Manifest = Manifest;
-/**
- * A resolved Malloy runtime configuration. The constructor takes either a
- * JSON string (legacy/compat) or a POJO plus an optional `ConfigOverlays`
- * dict, compiles the input into a typed tree, resolves all overlay
- * references, and builds the connection lookup via the connection registry.
- *
- * After construction:
- *   - `connections` — the `LookupConnection` runtime consumes. Starts as the
- *     lookup created from the resolved connections; `wrapConnections()` replaces
- *     it with a wrapped version for host-specific behavior.
- *   - `virtualMap` — extracted from the POJO as-is.
- *   - `manifestPath` — extracted from the POJO as-is (the raw string).
- *   - `manifestURL` — resolved URL of `malloy-manifest.json`, computed from
- *     `manifestPath` + the `configURL` carried on the `config` overlay (if
- *     any). `undefined` when no `configURL` is available. Runtime uses this
- *     to lazily read the manifest on the first persistence query. Builders
- *     that want to construct or mutate manifest state use the standalone
- *     `Manifest` class directly — they don't go through MalloyConfig.
- *   - `log` — validation warnings and overlay-resolution warnings.
- *
- * Typical usage:
- *
- *   // From a pre-loaded POJO (e.g. from `discoverConfig` or Publisher):
- *   const config = new MalloyConfig(pojo);
- *   const runtime = new Runtime({config, urlReader});
- *
- *   // From a JSON string:
- *   const config = new MalloyConfig(configText);
- *
- *   // With host-supplied overlays (local hosts after discovery):
- *   const config = new MalloyConfig(pojo, {
- *     config: contextOverlay({rootDirectory: ceilingURL}),
- *   });
- *
- *   // Wrap the connection lookup for host-specific behavior:
- *   config.wrapConnections(base => name => base(name) ?? fallback(name));
- *
- * The old async `new MalloyConfig(urlReader, configURL)` form has been
- * removed. Callers that need to load from a URL should pre-load via
- * `urlReader.readURL()` / `JSON.parse()` and pass the POJO, or use the
- * sync string form after reading the file.
- */
 class MalloyConfig {
-    constructor(sourceOrPojo, overlays) {
+    constructor(sourceOrPojo, optsOrOverlays) {
         const log = [];
         // Normalize input to a POJO.
         let pojo;
@@ -175,11 +133,28 @@ class MalloyConfig {
         // Compile → typed tree + validation warnings.
         const compiled = (0, config_compile_1.compileConfig)(pojo);
         log.push(...compiled.log);
-        // Merge the host-supplied overlays onto the defaults. Same-named
-        // entries replace defaults; new keys are added.
+        // Distinguish the new typed-options form from the legacy
+        // ConfigOverlays-dict form. Legacy dicts have function-valued slots
+        // (`config: () => ...`); new options have string/object fields.
+        const options = normalizeOptions(optsOrOverlays, log);
+        // configURL must parse as a URL — foundation joins paths against it
+        // (manifestURL, givensURL). rootDirectory is opaque; foundation just
+        // forwards it via the `config` overlay to whoever consumes it (e.g.
+        // DuckDB's databasePath default), so its shape is the consumer's call.
+        const configURL = validateURLString(options.configURL, 'configURL', log);
+        const rootDirectory = options.rootDirectory;
+        // Build the internal `config` overlay from the typed FS context. Other
+        // overlay slots (env, host-defined session/secret) ride alongside as
+        // host-supplied. The `config` slot is reserved here; if the host
+        // supplied one in `options.overlays`, normalizeOptions already warned
+        // and dropped it.
         const mergedOverlays = {
             ...(0, config_overlays_1.defaultConfigOverlays)(),
-            ...overlays,
+            ...options.overlays,
+            config: (0, config_overlays_1.contextOverlay)({
+                configURL,
+                rootDirectory,
+            }),
         };
         // Synchronous prep: extract literal sections (manifestPath, virtualMap),
         // pull out compiled connection subtrees, fabricate bare entries for
@@ -187,13 +162,18 @@ class MalloyConfig {
         // Reference resolution for connection properties is *not* done here —
         // it happens async at `lookupConnection` time, so overlays that touch
         // IO (secret stores, session reads) have a natural async seam.
-        const prepared = (0, config_resolve_1.prepareConfig)(compiled.compiled, log);
+        const prepared = (0, config_resolve_1.prepareConfig)(compiled.compiled, mergedOverlays, log);
         this._managedLookup = (0, config_lookup_1.buildManagedLookup)(prepared.compiledConnections, mergedOverlays, log);
         this._connections = this._managedLookup;
         this._overlays = mergedOverlays;
         this.virtualMap = toVirtualMap(prepared.virtualMap);
+        this.configURL = configURL;
+        this.rootDirectory = rootDirectory;
         this.manifestPath = prepared.manifestPath;
-        this.manifestURL = computeManifestURL(prepared.manifestPath, mergedOverlays, log);
+        this.manifestURL = computeManifestURL(prepared.manifestPath, configURL);
+        this.givensPath = prepared.givensPath;
+        this.givensURL = computeGivensURL(prepared.givensPath, configURL, log);
+        this.finalizeGivens = prepared.finalizeGivens;
         this.log = log;
     }
     /**
@@ -318,22 +298,12 @@ const MANIFEST_FILENAME = 'malloy-manifest.json';
  *   - A trailing slash is forced onto the directory portion so that the
  *     final `new URL(MANIFEST_FILENAME, dir)` joins correctly.
  */
-function computeManifestURL(manifestPath, overlays, log) {
-    const configOverlay = overlays['config'];
-    const configURLValue = configOverlay === null || configOverlay === void 0 ? void 0 : configOverlay(['configURL']);
-    if (isThenable(configURLValue)) {
-        log.push({
-            message: 'the `config` overlay returned a Promise for `configURL`; `configURL` must be resolved synchronously. manifestURL will be undefined and persistence will not work.',
-            severity: 'warn',
-            code: 'config-overlay',
-        });
+function computeManifestURL(manifestPath, configURL) {
+    if (!configURL)
         return undefined;
-    }
-    if (typeof configURLValue !== 'string')
-        return undefined;
-    let configURL;
+    let baseURL;
     try {
-        configURL = new URL(configURLValue);
+        baseURL = new URL(configURL);
     }
     catch {
         return undefined;
@@ -341,7 +311,7 @@ function computeManifestURL(manifestPath, overlays, log) {
     const path = manifestPath !== null && manifestPath !== void 0 ? manifestPath : DEFAULT_MANIFEST_PATH;
     let manifestRoot;
     try {
-        manifestRoot = new URL(path, configURL);
+        manifestRoot = new URL(path, baseURL);
     }
     catch {
         return undefined;
@@ -350,7 +320,124 @@ function computeManifestURL(manifestPath, overlays, log) {
     const dirURL = asString.endsWith('/')
         ? manifestRoot
         : new URL(asString + '/');
-    return new URL(MANIFEST_FILENAME, dirURL);
+    return new URL(MANIFEST_FILENAME, dirURL).toString();
+}
+/**
+ * Resolve `givensPath` to a full URL string, joined against `configURL`
+ * so relative paths anchor at the project's `malloy-config.json`
+ * directory. Returns `undefined` and warns when `givensPath` was set but
+ * resolution can't proceed — silent drop here is unfriendly because
+ * unlike `manifestPath`, `givensPath` has no graceful-fallback story.
+ */
+function computeGivensURL(givensPath, configURL, log) {
+    if (!givensPath)
+        return undefined;
+    if (!configURL) {
+        log.push({
+            message: 'givensPath is set but no configURL is available; per-runtime givens will not be loaded. Pass `configURL` (or use an absolute URL such as `file:///...`).',
+            severity: 'warn',
+            code: 'config-overlay',
+        });
+        return undefined;
+    }
+    let baseURL;
+    try {
+        baseURL = new URL(configURL);
+    }
+    catch {
+        return undefined;
+    }
+    try {
+        return new URL(givensPath, baseURL).toString();
+    }
+    catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        log.push({
+            message: `givensPath '${givensPath}' could not be resolved against configURL '${configURL}': ${msg}`,
+            severity: 'warn',
+            code: 'config-validation',
+        });
+        return undefined;
+    }
+}
+/**
+ * Distinguish the new typed-options form (`{configURL?, rootDirectory?,
+ * overlays?}`) from the legacy `ConfigOverlays`-dict form (`{config: fn,
+ * env: fn, ...}`) by checking for function-valued top-level slots. Legacy
+ * inputs are adapted: extract `configURL` and `rootDirectory` from
+ * `overlays.config?.(['name'])` (sync only — async overlays warn and
+ * drop), preserve the rest as `options.overlays`. New inputs pass
+ * through, but a non-empty `overlays.config` is reserved-slot collision —
+ * warn and drop.
+ */
+function normalizeOptions(optsOrOverlays, log) {
+    if (optsOrOverlays === undefined)
+        return {};
+    if (isLegacyOverlays(optsOrOverlays)) {
+        return adaptLegacyOverlays(optsOrOverlays, log);
+    }
+    const opts = optsOrOverlays;
+    if (opts.overlays && 'config' in opts.overlays) {
+        log.push({
+            message: '`config` is reserved by MalloyConfig; pass `configURL` and `rootDirectory` directly instead. Supplied `overlays.config` ignored.',
+            severity: 'warn',
+            code: 'config-overlay',
+        });
+        const { config: _config, ...rest } = opts.overlays;
+        return { ...opts, overlays: rest };
+    }
+    return opts;
+}
+function isLegacyOverlays(arg) {
+    for (const v of Object.values(arg)) {
+        if (typeof v === 'function')
+            return true;
+    }
+    return false;
+}
+function adaptLegacyOverlays(overlays, log) {
+    const cfg = overlays['config'];
+    if (!cfg)
+        return { overlays };
+    const configURL = readSyncString(cfg, 'configURL', log);
+    const rootDirectory = readSyncString(cfg, 'rootDirectory', log);
+    // Strip the legacy `config` overlay; its values are now typed fields.
+    // Any other slots (env, host-defined) ride through.
+    const { config: _config, ...rest } = overlays;
+    return { configURL, rootDirectory, overlays: rest };
+}
+function readSyncString(overlay, key, log) {
+    const v = overlay([key]);
+    if ((0, config_overlays_1.isThenable)(v)) {
+        log.push({
+            message: `the legacy \`config\` overlay returned a Promise for \`${key}\`; top-level FS context must resolve synchronously. ${key} will be undefined.`,
+            severity: 'warn',
+            code: 'config-overlay',
+        });
+        return undefined;
+    }
+    return typeof v === 'string' ? v : undefined;
+}
+/**
+ * Diagnose a URL-shaped string. Returns the string back when valid,
+ * undefined (with a warning) when not. Empty/undefined inputs return
+ * undefined silently — those are the "not supplied" case.
+ */
+function validateURLString(value, fieldName, log) {
+    if (value === undefined)
+        return undefined;
+    try {
+        new URL(value);
+        return value;
+    }
+    catch {
+        log.push({
+            message: `${fieldName} must be a URL-shaped string (e.g. 'file:///path/to/...'), got '${value}'. In Node, use \`url.pathToFileURL(path).toString()\`.`,
+            severity: 'warn',
+            code: 'config-validation',
+        });
+        return undefined;
+    }
 }
 /**
  * Convert the raw virtualMap POJO shape (a dict of dicts of strings) into
@@ -377,11 +464,6 @@ function toVirtualMap(raw) {
 function isRecord(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
-function isThenable(value) {
-    return (typeof value === 'object' &&
-        value !== null &&
-        typeof value.then === 'function');
-}
 function isBuildManifestEntry(value) {
     return isRecord(value) && typeof value['tableName'] === 'string';
 }

package/dist/api/foundation/config_compile.js

@@ -6,9 +6,12 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.compileConfig = compileConfig;
 const registry_1 = require("../../connection/registry");
+const closest_match_1 = require("../../util/closest_match");
 const TOP_LEVEL_SECTIONS = {
     connections: compileConnections,
     manifestPath: compileManifestPath,
+    givensPath: compileGivensPath,
+    finalizeGivens: compileFinalizeGivens,
     virtualMap: compileVirtualMap,
     includeDefaultConnections: compileIncludeDefaultConnections,
 };
@@ -34,7 +37,7 @@ function compileConfig(pojo) {
     for (const [key, value] of Object.entries(pojo)) {
         const compiler = TOP_LEVEL_SECTIONS[key];
         if (!compiler) {
-            const suggestion = closestMatch(key, [...KNOWN_TOP_LEVEL_KEYS]);
+            const suggestion = (0, closest_match_1.closestMatch)(key, [...KNOWN_TOP_LEVEL_KEYS]);
             const hint = suggestion ? `. Did you mean "${suggestion}"?` : '';
             log.push(makeWarning(key, `unknown config key "${key}"${hint}`));
             continue;
@@ -72,7 +75,7 @@ function compileConnections(value, log) {
             continue;
         }
         if (!registeredTypes.has(is)) {
-            const suggestion = closestMatch(is, [...registeredTypes]);
+            const suggestion = (0, closest_match_1.closestMatch)(is, [...registeredTypes]);
             const hint = suggestion ? ` Did you mean "${suggestion}"?` : '';
             log.push(makeWarning(`${prefix}.is`, `unknown connection type "${is}".${hint} Available types: ${[...registeredTypes].join(', ')}`));
             continue;
@@ -94,7 +97,7 @@ function compileConnectionEntry(prefix, typeName, rawEntry, log) {
             continue;
         const propDef = propMap.get(key);
         if (!propDef) {
-            const suggestion = closestMatch(key, [...propMap.keys()]);
+            const suggestion = (0, closest_match_1.closestMatch)(key, [...propMap.keys()]);
             const hint = suggestion ? `. Did you mean "${suggestion}"?` : '';
             log.push(makeWarning(`${prefix}.${key}`, `unknown property "${key}" for connection type "${typeName}"${hint}`));
             continue;
@@ -142,8 +145,28 @@ function compileConnectionProperty(path, propDef, value, log) {
 // Pass-through sections
 // =============================================================================
 function compileManifestPath(value, log) {
+    const ref = asReferenceShape(value);
+    if (ref !== undefined)
+        return ref;
+    if (typeof value !== 'string') {
+        log.push(makeWarning('manifestPath', '"manifestPath" should be a string or an overlay reference'));
+        return undefined;
+    }
+    return { kind: 'value', value };
+}
+function compileGivensPath(value, log) {
+    const ref = asReferenceShape(value);
+    if (ref !== undefined)
+        return ref;
     if (typeof value !== 'string') {
-        log.push(makeWarning('manifestPath', '"manifestPath" should be a string'));
+        log.push(makeWarning('givensPath', '"givensPath" should be a string or an overlay reference'));
+        return undefined;
+    }
+    return { kind: 'value', value };
+}
+function compileFinalizeGivens(value, log) {
+    if (!Array.isArray(value) || !value.every(v => typeof v === 'string')) {
+        log.push(makeWarning('finalizeGivens', '"finalizeGivens" should be an array of given names'));
         return undefined;
     }
     return { kind: 'value', value };
@@ -226,35 +249,4 @@ function checkValueType(value, expectedType) {
     }
     return undefined;
 }
-function levenshtein(a, b) {
-    const m = a.length;
-    const n = b.length;
-    const dp = Array.from({ length: m + 1 }, () => Array(n + 1).fill(0));
-    for (let i = 0; i <= m; i++)
-        dp[i][0] = i;
-    for (let j = 0; j <= n; j++)
-        dp[0][j] = j;
-    for (let i = 1; i <= m; i++) {
-        for (let j = 1; j <= n; j++) {
-            const cost = a[i - 1] === b[j - 1] ? 0 : 1;
-            dp[i][j] = Math.min(dp[i - 1][j] + 1, dp[i][j - 1] + 1, dp[i - 1][j - 1] + cost);
-        }
-    }
-    return dp[m][n];
-}
-function closestMatch(input, candidates) {
-    if (candidates.length === 0)
-        return undefined;
-    let best = candidates[0];
-    let bestDist = Infinity;
-    for (const c of candidates) {
-        const dist = levenshtein(input.toLowerCase(), c.toLowerCase());
-        if (dist < bestDist) {
-            bestDist = dist;
-            best = c;
-        }
-    }
-    const maxDist = Math.max(1, Math.floor(Math.max(input.length, best.length) / 3));
-    return bestDist <= maxDist ? best : undefined;
-}
 //# sourceMappingURL=config_compile.js.map

package/dist/api/foundation/config_discover.js

@@ -6,7 +6,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.discoverConfig = discoverConfig;
 const config_1 = require("./config");
-const config_overlays_1 = require("./config_overlays");
 const SHARED_FILENAME = 'malloy-config.json';
 const LOCAL_FILENAME = 'malloy-config-local.json';
 /**
@@ -66,14 +65,11 @@ async function discoverConfig(startURL, ceilingURL, urlReader, extraOverlays) {
     return null;
 }
 function buildConfig(hit, ceilingURL, extraOverlays) {
-    const discoveryOverlays = {
-        config: (0, config_overlays_1.contextOverlay)({
-            rootDirectory: ceilingURL.toString(),
-            configURL: hit.configURL.toString(),
-        }),
-    };
-    const merged = { ...discoveryOverlays, ...extraOverlays };
-    return new config_1.MalloyConfig(hit.pojo, merged);
+    return new config_1.MalloyConfig(hit.pojo, {
+        configURL: hit.configURL.toString(),
+        rootDirectory: ceilingURL.toString(),
+        overlays: extraOverlays,
+    });
 }
 async function tryReadAtLevel(dirURL, urlReader) {
     const sharedURL = new URL(SHARED_FILENAME, dirURL);

package/dist/api/foundation/config_overlays.d.ts

@@ -59,3 +59,9 @@ export declare function contextOverlay(dict: Record<string, unknown>): Overlay;
  * resolve to "not present".
  */
 export declare function defaultConfigOverlays(): ConfigOverlays;
+/**
+ * Type guard for "looks like a Promise." Used by sync-peek call sites
+ * (`computeManifestURL`, `resolveSyncStringSetting`) to detect when a host
+ * mistakenly wired an async overlay into a slot that's read synchronously.
+ */
+export declare function isThenable(value: unknown): value is PromiseLike<unknown>;

package/dist/api/foundation/config_overlays.js

@@ -7,6 +7,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.envOverlay = envOverlay;
 exports.contextOverlay = contextOverlay;
 exports.defaultConfigOverlays = defaultConfigOverlays;
+exports.isThenable = isThenable;
 /**
  * Built-in `env` overlay: reads `process.env[path[0]]`.
  *
@@ -48,4 +49,15 @@ function defaultConfigOverlays() {
         config: () => undefined,
     };
 }
+/**
+ * Type guard for "looks like a Promise." Used by sync-peek call sites
+ * (`computeManifestURL`, `resolveSyncStringSetting`) to detect when a host
+ * mistakenly wired an async overlay into a slot that's read synchronously.
+ */
+function isThenable(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        'then' in value &&
+        typeof value.then === 'function');
+}
 //# sourceMappingURL=config_overlays.js.map

package/dist/api/foundation/config_resolve.d.ts

@@ -1,5 +1,6 @@
 import type { LogMessage } from '../../lang/parse-log';
 import type { ConfigDict } from './config_compile';
+import type { ConfigOverlays } from './config_overlays';
 /**
  * The synchronous slice of config preparation. What the `MalloyConfig`
  * constructor needs *before* any overlay IO happens:
@@ -18,6 +19,8 @@ import type { ConfigDict } from './config_compile';
 export interface PreparedConfig {
     compiledConnections: Record<string, ConfigDict>;
     manifestPath?: string;
+    givensPath?: string;
+    finalizeGivens?: ReadonlyArray<string>;
     virtualMap?: unknown;
 }
 /**
@@ -36,4 +39,4 @@ export interface PreparedConfig {
  * via `includeDefaultConnections`. Property defaults are filled in at
  * lookup time alongside reference resolution.
  */
-export declare function prepareConfig(compiled: ConfigDict, _log: LogMessage[]): PreparedConfig;
+export declare function prepareConfig(compiled: ConfigDict, overlays: ConfigOverlays, log: LogMessage[]): PreparedConfig;