@malloydata/malloy 0.0.364 → 0.0.366

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

@@ -1,13 +1,15 @@
 import type { URLReader } from '../../runtime_types';
 import type { Connection, LookupConnection } from '../../connection/types';
 import type { ConnectionConfigEntry } from '../../connection/registry';
-import type { BuildID, BuildManifest, BuildManifestEntry } from '../../model/malloy_types';
+import type { LogMessage } from '../../lang/parse-log';
+import type { BuildID, BuildManifest, BuildManifestEntry, VirtualMap } from '../../model/malloy_types';
 /**
  * The parsed contents of a malloy-config.json file.
  */
 export interface MalloyProjectConfig {
     connections?: Record<string, ConnectionConfigEntry>;
     manifestPath?: string;
+    virtualMap?: VirtualMap;
 }
 /**
  * In-memory manifest store. Reads, updates, and serializes manifest data.
@@ -71,9 +73,8 @@ export declare class Manifest {
     private _loadParsed;
 }
 /**
- * Loads and holds a Malloy project configuration (connections + manifest).
- *
- * Two construction modes:
+ * Loads and holds a Malloy project configuration (connections + manifest +
+ * virtualMap). Pass directly to Runtime — everything flows automatically.
  *
  *   // From a URL — reads config + manifest via URLReader
  *   const config = new MalloyConfig(urlReader, configURL);
@@ -82,19 +83,23 @@ export declare class Manifest {
  *   // From text you already have
  *   const config = new MalloyConfig(configText);
  *
- *   // Either way, construct Runtime the same way
- *   const runtime = new Runtime({
- *     urlReader,
- *     connections: config.connections,
- *     buildManifest: config.manifest.buildManifest,
- *   });
+ *   // Either way, pass to Runtime — connections, buildManifest, virtualMap
+ *   // all come from the config. No manual wiring needed.
+ *   const runtime = new Runtime({config, urlReader});
+ *
+ * To override specific fields, mutate the config before passing:
+ *   config.connectionMap = myCustomConnections;
  */
 export declare class MalloyConfig {
     private readonly _urlReader?;
     private readonly _configURL?;
     private _data;
+    private _log;
     private _connectionMap;
     private readonly _manifest;
+    private _managedLookup;
+    private _connectionLookupOverride;
+    private _onConnectionCreated;
     constructor(configText: string);
     constructor(urlReader: URLReader, configURL: string);
     /**
@@ -119,13 +124,46 @@ export declare class MalloyConfig {
     set connectionMap(map: Record<string, ConnectionConfigEntry>);
     /**
      * A LookupConnection built from the current connectionMap via the
-     * connection type registry. Each access creates a fresh snapshot —
-     * changing connectionMap after this does not affect previously-returned
-     * LookupConnections.
+     * connection type registry. The result is cached — repeated access
+     * returns the same object (and the same underlying connections).
+     *
+     * If `connectionLookup` has been set, returns the override instead.
+     *
+     * Changing `connectionMap` invalidates the cache; the next access
+     * creates a fresh ManagedConnectionLookup.
      */
     get connections(): LookupConnection<Connection>;
+    /**
+     * Override the connection lookup entirely. When set, the `connections`
+     * getter returns this instead of building from `connectionMap`.
+     * Use this when you need to merge config connections with other sources.
+     */
+    get connectionLookup(): LookupConnection<Connection> | undefined;
+    set connectionLookup(lookup: LookupConnection<Connection> | undefined);
+    /**
+     * Callback invoked once per connection immediately after factory creation.
+     * Use for post-creation setup (e.g., registering WASM file handlers).
+     * Must be set before the first connection is looked up.
+     */
+    set onConnectionCreated(cb: ((name: string, connection: Connection) => void) | undefined);
+    /**
+     * Close all connections created by this config's internal managed lookup.
+     * Does nothing if connections were overridden via `connectionLookup`.
+     */
+    close(): Promise<void>;
     /**
      * The Manifest object. Always exists, may be empty if not yet loaded.
      */
     get manifest(): Manifest;
+    /**
+     * The VirtualMap parsed from config, if present.
+     */
+    get virtualMap(): VirtualMap | undefined;
+    /**
+     * Errors and warnings from parsing and validating the config.
+     * Includes JSON parse errors (severity 'error') and schema validation
+     * warnings (severity 'warn') such as unknown keys, unknown connection
+     * types, wrong value types, and missing environment variables.
+     */
+    get log(): LogMessage[];
 }

package/dist/api/foundation/config.js

@@ -123,30 +123,18 @@ class Manifest {
         }
         // New format: {entries: {...}, strict?: boolean}
         // Old format: {buildId: {tableName}, ...} (flat record, no "entries" key)
-        let entries;
-        if (parsed['entries'] && typeof parsed['entries'] === 'object') {
-            entries = parsed['entries'];
-        }
-        else {
-            // Treat as old flat-record format: every key with a tableName is an entry
-            entries = {};
-            for (const [key, val] of Object.entries(parsed)) {
-                if (key !== 'strict' &&
-                    val &&
-                    typeof val === 'object' &&
-                    'tableName' in val) {
-                    entries[key] = val;
-                }
+        const rawEntries = isRecord(parsed['entries']) ? parsed['entries'] : parsed;
+        for (const [key, val] of Object.entries(rawEntries)) {
+            if (key !== 'strict' && isBuildManifestEntry(val)) {
+                this._manifest.entries[key] = val;
             }
         }
-        Object.assign(this._manifest.entries, entries);
     }
 }
 exports.Manifest = Manifest;
 /**
- * Loads and holds a Malloy project configuration (connections + manifest).
- *
- * Two construction modes:
+ * Loads and holds a Malloy project configuration (connections + manifest +
+ * virtualMap). Pass directly to Runtime — everything flows automatically.
  *
  *   // From a URL — reads config + manifest via URLReader
  *   const config = new MalloyConfig(urlReader, configURL);
@@ -155,17 +143,20 @@ exports.Manifest = Manifest;
  *   // From text you already have
  *   const config = new MalloyConfig(configText);
  *
- *   // Either way, construct Runtime the same way
- *   const runtime = new Runtime({
- *     urlReader,
- *     connections: config.connections,
- *     buildManifest: config.manifest.buildManifest,
- *   });
+ *   // Either way, pass to Runtime — connections, buildManifest, virtualMap
+ *   // all come from the config. No manual wiring needed.
+ *   const runtime = new Runtime({config, urlReader});
+ *
+ * To override specific fields, mutate the config before passing:
+ *   config.connectionMap = myCustomConnections;
  */
 class MalloyConfig {
     constructor(urlReaderOrText, configURL) {
+        this._log = [];
         if (typeof urlReaderOrText === 'string') {
-            this._data = parseConfigText(urlReaderOrText);
+            const { config, log } = parseConfigText(urlReaderOrText);
+            this._data = config;
+            this._log = log;
             this._connectionMap = this._data.connections
                 ? { ...this._data.connections }
                 : undefined;
@@ -199,7 +190,9 @@ class MalloyConfig {
             return;
         const result = await this._urlReader.readURL(new URL(this._configURL));
         const contents = typeof result === 'string' ? result : result.contents;
-        this._data = parseConfigText(contents);
+        const parsed = parseConfigText(contents);
+        this._data = parsed.config;
+        this._log = parsed.log;
         this._connectionMap = this._data.connections
             ? { ...this._data.connections }
             : undefined;
@@ -219,18 +212,59 @@ class MalloyConfig {
     }
     set connectionMap(map) {
         this._connectionMap = map;
+        // Invalidate cached managed lookup — new map means new connections
+        this._managedLookup = undefined;
     }
     /**
      * A LookupConnection built from the current connectionMap via the
-     * connection type registry. Each access creates a fresh snapshot —
-     * changing connectionMap after this does not affect previously-returned
-     * LookupConnections.
+     * connection type registry. The result is cached — repeated access
+     * returns the same object (and the same underlying connections).
+     *
+     * If `connectionLookup` has been set, returns the override instead.
+     *
+     * Changing `connectionMap` invalidates the cache; the next access
+     * creates a fresh ManagedConnectionLookup.
      */
     get connections() {
+        if (this._connectionLookupOverride) {
+            return this._connectionLookupOverride;
+        }
         if (!this._connectionMap) {
             throw new Error('Config not loaded. Call load() or loadConfig() first.');
         }
-        return (0, registry_1.createConnectionsFromConfig)({ connections: this._connectionMap });
+        if (!this._managedLookup) {
+            this._managedLookup = (0, registry_1.createConnectionsFromConfig)({ connections: this._connectionMap }, this._onConnectionCreated);
+        }
+        return this._managedLookup;
+    }
+    /**
+     * Override the connection lookup entirely. When set, the `connections`
+     * getter returns this instead of building from `connectionMap`.
+     * Use this when you need to merge config connections with other sources.
+     */
+    get connectionLookup() {
+        return this._connectionLookupOverride;
+    }
+    set connectionLookup(lookup) {
+        this._connectionLookupOverride = lookup;
+    }
+    /**
+     * Callback invoked once per connection immediately after factory creation.
+     * Use for post-creation setup (e.g., registering WASM file handlers).
+     * Must be set before the first connection is looked up.
+     */
+    set onConnectionCreated(cb) {
+        this._onConnectionCreated = cb;
+    }
+    /**
+     * Close all connections created by this config's internal managed lookup.
+     * Does nothing if connections were overridden via `connectionLookup`.
+     */
+    async close() {
+        if (this._managedLookup) {
+            await this._managedLookup.close();
+            this._managedLookup = undefined;
+        }
     }
     /**
      * The Manifest object. Always exists, may be empty if not yet loaded.
@@ -238,16 +272,230 @@ class MalloyConfig {
     get manifest() {
         return this._manifest;
     }
+    /**
+     * The VirtualMap parsed from config, if present.
+     */
+    get virtualMap() {
+        var _a;
+        return (_a = this._data) === null || _a === void 0 ? void 0 : _a.virtualMap;
+    }
+    /**
+     * Errors and warnings from parsing and validating the config.
+     * Includes JSON parse errors (severity 'error') and schema validation
+     * warnings (severity 'warn') such as unknown keys, unknown connection
+     * types, wrong value types, and missing environment variables.
+     */
+    get log() {
+        return this._log;
+    }
 }
 exports.MalloyConfig = MalloyConfig;
 /**
  * Parse a config JSON string into a MalloyProjectConfig.
  * Invalid connection entries (missing `is`) are silently dropped.
+ * Returns the processed config and validation log.
  */
 function parseConfigText(jsonText) {
-    var _a;
-    const parsed = JSON.parse(jsonText);
-    const connections = Object.fromEntries(Object.entries((_a = parsed.connections) !== null && _a !== void 0 ? _a : {}).filter(([, v]) => (0, registry_1.isConnectionConfigEntry)(v)));
-    return { ...parsed, connections };
+    let parsed;
+    try {
+        parsed = JSON.parse(jsonText);
+    }
+    catch (e) {
+        return {
+            config: {},
+            log: [
+                {
+                    message: `Invalid JSON: ${e instanceof Error ? e.message : String(e)}`,
+                    severity: 'error',
+                    code: 'config-validation',
+                },
+            ],
+        };
+    }
+    if (!isRecord(parsed)) {
+        return {
+            config: {},
+            log: [
+                {
+                    message: 'config is not a JSON object',
+                    severity: 'error',
+                    code: 'config-validation',
+                },
+            ],
+        };
+    }
+    const rawConnections = parsed['connections'];
+    const connectionEntries = Object.entries(isRecord(rawConnections) ? rawConnections : {}).filter((entry) => (0, registry_1.isConnectionConfigEntry)(entry[1]));
+    const connections = Object.fromEntries(connectionEntries);
+    const result = { ...parsed, connections };
+    const virtualMap = parsed['virtualMap'];
+    if (virtualMap &&
+        typeof virtualMap === 'object' &&
+        !Array.isArray(virtualMap)) {
+        const outer = new Map();
+        for (const [connName, inner] of Object.entries(virtualMap)) {
+            if (inner && typeof inner === 'object' && !Array.isArray(inner)) {
+                const innerMap = new Map();
+                for (const [virtualName, tablePath] of Object.entries(inner)) {
+                    if (typeof tablePath === 'string') {
+                        innerMap.set(virtualName, tablePath);
+                    }
+                }
+                outer.set(connName, innerMap);
+            }
+        }
+        result.virtualMap = outer;
+    }
+    return { config: result, log: validateConfig(parsed) };
+}
+const KNOWN_TOP_LEVEL_KEYS = new Set([
+    'connections',
+    'manifestPath',
+    'virtualMap',
+]);
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function isBuildManifestEntry(value) {
+    return isRecord(value) && typeof value['tableName'] === 'string';
+}
+function makeWarning(path, message) {
+    return {
+        message: `${path}: ${message}`,
+        severity: 'warn',
+        code: 'config-validation',
+    };
+}
+/**
+ * Validate a parsed config object against the connection type registry.
+ * Returns LogMessage[] — does not throw.
+ */
+function validateConfig(data) {
+    const log = [];
+    for (const key of Object.keys(data)) {
+        if (!KNOWN_TOP_LEVEL_KEYS.has(key)) {
+            const suggestion = closestMatch(key, [...KNOWN_TOP_LEVEL_KEYS]);
+            const hint = suggestion ? `. Did you mean "${suggestion}"?` : '';
+            log.push(makeWarning(key, `unknown config key "${key}"${hint}`));
+        }
+    }
+    if (data['manifestPath'] !== undefined &&
+        typeof data['manifestPath'] !== 'string') {
+        log.push(makeWarning('manifestPath', '"manifestPath" should be a string'));
+    }
+    const connections = data['connections'];
+    if (connections === undefined)
+        return log;
+    if (!isRecord(connections)) {
+        log.push(makeWarning('connections', '"connections" should be an object'));
+        return log;
+    }
+    const registeredTypes = new Set((0, registry_1.getRegisteredConnectionTypes)());
+    for (const [name, rawEntry] of Object.entries(connections)) {
+        const prefix = `connections.${name}`;
+        if (!isRecord(rawEntry)) {
+            log.push(makeWarning(prefix, 'should be an object'));
+            continue;
+        }
+        if (!rawEntry['is']) {
+            log.push(makeWarning(prefix, 'missing required "is" field (connection type)'));
+            continue;
+        }
+        if (typeof rawEntry['is'] !== 'string') {
+            log.push(makeWarning(`${prefix}.is`, '"is" should be a string'));
+            continue;
+        }
+        const typeName = rawEntry['is'];
+        if (!registeredTypes.has(typeName)) {
+            const suggestion = closestMatch(typeName, [...registeredTypes]);
+            const hint = suggestion ? ` Did you mean "${suggestion}"?` : '';
+            log.push(makeWarning(`${prefix}.is`, `unknown connection type "${typeName}".${hint} Available types: ${[...registeredTypes].join(', ')}`));
+            continue;
+        }
+        const props = (0, registry_1.getConnectionProperties)(typeName);
+        if (!props)
+            continue;
+        const knownProps = new Map(props.map(p => [p.name, p]));
+        for (const [key, value] of Object.entries(rawEntry)) {
+            if (key === 'is')
+                continue;
+            const propDef = knownProps.get(key);
+            if (!propDef) {
+                const suggestion = closestMatch(key, [...knownProps.keys()]);
+                const hint = suggestion ? `. Did you mean "${suggestion}"?` : '';
+                log.push(makeWarning(`${prefix}.${key}`, `unknown property "${key}" for connection type "${typeName}"${hint}`));
+                continue;
+            }
+            // For env var references on non-json props, check the variable exists.
+            if (propDef.type !== 'json' && (0, registry_1.isValueRef)(value)) {
+                const env = value.env;
+                if (process.env[env] === undefined) {
+                    log.push(makeWarning(`${prefix}.${key}`, `environment variable "${env}" is not set`));
+                }
+                continue;
+            }
+            const typeError = checkValueType(value, propDef.type);
+            if (typeError) {
+                log.push(makeWarning(`${prefix}.${key}`, `${typeError} (expected ${propDef.type})`));
+            }
+        }
+    }
+    return log;
+}
+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;
+}
+function checkValueType(value, expectedType) {
+    if (value === undefined || value === null)
+        return undefined;
+    switch (expectedType) {
+        case 'number':
+            if (typeof value !== 'number')
+                return `should be a number, got ${typeof value}`;
+            break;
+        case 'boolean':
+            if (typeof value !== 'boolean')
+                return `should be a boolean, got ${typeof value}`;
+            break;
+        case 'string':
+        case 'password':
+        case 'secret':
+        case 'file':
+        case 'text':
+            if (typeof value !== 'string')
+                return `should be a string, got ${typeof value}`;
+            break;
+        case 'json':
+            break;
+    }
+    return undefined;
 }
 //# sourceMappingURL=config.js.map

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

@@ -4,6 +4,7 @@ import type { ModelDef, Query as InternalQuery, SearchIndexResult, SearchValueMa
 import type { Dialect } from '../../dialect';
 import type { RunSQLOptions } from '../../run_sql_options';
 import type { CacheManager } from './cache';
+import type { MalloyConfig } from './config';
 import type { ParseOptions, CompileOptions, CompileQueryOptions } from './types';
 import type { PreparedResult, Explore } from './core';
 import { Model, PreparedQuery } from './core';
@@ -13,11 +14,17 @@ type ModelString = string;
 type QueryURL = URL;
 type QueryString = string;
 type Connectionable = {
+    config: MalloyConfig;
+    connection?: undefined;
+    connections?: LookupConnection<Connection>;
+} | {
     connection: Connection;
     connections?: undefined;
+    config?: undefined;
 } | {
     connections: LookupConnection<Connection>;
     connection?: undefined;
+    config?: undefined;
 };
 declare class FluentState<T> {
     protected runtime: Runtime;
@@ -39,14 +46,13 @@ export declare class Runtime {
     private _connections;
     private _eventStream;
     private _cacheManager;
+    private _config;
     private _buildManifest;
     private _virtualMap;
-    constructor({ urlReader, connections, connection, eventStream, cacheManager, buildManifest, virtualMap, }: {
+    constructor({ urlReader, connections, connection, config, eventStream, cacheManager, }: {
         urlReader?: URLReader;
         eventStream?: EventStream;
         cacheManager?: CacheManager;
-        buildManifest?: BuildManifest;
-        virtualMap?: VirtualMap;
     } & Connectionable);
     /**
      * @return The `CacheManager` for this runtime instance.
@@ -69,6 +75,10 @@ export declare class Runtime {
      * When set, compiled queries automatically resolve persist sources
      * against this manifest. Can be overridden per-query via
      * CompileQueryOptions.buildManifest.
+     *
+     * When constructed with a MalloyConfig, falls through to
+     * config.manifest.buildManifest (a live reference — builder
+     * mutations are visible automatically).
      */
     get buildManifest(): BuildManifest | undefined;
     set buildManifest(manifest: BuildManifest | undefined);
@@ -77,6 +87,9 @@ export declare class Runtime {
      * When set, compiled queries automatically resolve virtual sources
      * against this map. Can be overridden per-query via
      * CompileQueryOptions.virtualMap.
+     *
+     * When constructed with a MalloyConfig, falls through to
+     * config.virtualMap.
      */
     get virtualMap(): VirtualMap | undefined;
     set virtualMap(map: VirtualMap | undefined);
@@ -152,21 +165,17 @@ export declare class Runtime {
 }
 export declare class ConnectionRuntime extends Runtime {
     readonly rawConnections: Connection[];
-    constructor({ urlReader, connections, buildManifest, virtualMap, }: {
+    constructor({ urlReader, connections, }: {
         urlReader?: URLReader;
         connections: Connection[];
-        buildManifest?: BuildManifest;
-        virtualMap?: VirtualMap;
     });
 }
 export declare class SingleConnectionRuntime<T extends Connection = Connection> extends Runtime {
     readonly connection: T;
-    constructor({ urlReader, connection, eventStream, cacheManager, buildManifest, virtualMap, }: {
+    constructor({ urlReader, connection, eventStream, cacheManager, }: {
         urlReader?: URLReader;
         eventStream?: EventStream;
         cacheManager?: CacheManager;
-        buildManifest?: BuildManifest;
-        virtualMap?: VirtualMap;
         connection: T;
     });
     get supportsNesting(): boolean;

package/dist/api/foundation/runtime.js

@@ -46,11 +46,15 @@ class FluentState {
  * An environment for compiling and running Malloy queries.
  */
 class Runtime {
-    constructor({ urlReader, connections, connection, eventStream, cacheManager, buildManifest, virtualMap, }) {
+    constructor({ urlReader, connections, connection, config, eventStream, cacheManager, }) {
         this.isTestRuntime = false;
-        if (connections === undefined) {
+        if (config !== undefined) {
+            this._config = config;
+            connections = connections !== null && connections !== void 0 ? connections : config.connections;
+        }
+        else if (connections === undefined) {
             if (connection === undefined) {
-                throw new Error('A LookupConnection<Connection> or Connection is required.');
+                throw new Error('A MalloyConfig, LookupConnection<Connection>, or Connection is required.');
             }
             connections = {
                 lookupConnection: () => Promise.resolve(connection),
@@ -63,8 +67,6 @@ class Runtime {
         this._connections = connections;
         this._eventStream = eventStream;
         this._cacheManager = cacheManager;
-        this._buildManifest = buildManifest;
-        this._virtualMap = virtualMap;
     }
     /**
      * @return The `CacheManager` for this runtime instance.
@@ -95,9 +97,14 @@ class Runtime {
      * When set, compiled queries automatically resolve persist sources
      * against this manifest. Can be overridden per-query via
      * CompileQueryOptions.buildManifest.
+     *
+     * When constructed with a MalloyConfig, falls through to
+     * config.manifest.buildManifest (a live reference — builder
+     * mutations are visible automatically).
      */
     get buildManifest() {
-        return this._buildManifest;
+        var _a, _b;
+        return (_a = this._buildManifest) !== null && _a !== void 0 ? _a : (_b = this._config) === null || _b === void 0 ? void 0 : _b.manifest.buildManifest;
     }
     set buildManifest(manifest) {
         this._buildManifest = manifest;
@@ -107,9 +114,13 @@ class Runtime {
      * When set, compiled queries automatically resolve virtual sources
      * against this map. Can be overridden per-query via
      * CompileQueryOptions.virtualMap.
+     *
+     * When constructed with a MalloyConfig, falls through to
+     * config.virtualMap.
      */
     get virtualMap() {
-        return this._virtualMap;
+        var _a, _b;
+        return (_a = this._virtualMap) !== null && _a !== void 0 ? _a : (_b = this._config) === null || _b === void 0 ? void 0 : _b.virtualMap;
     }
     set virtualMap(map) {
         this._virtualMap = map;
@@ -236,25 +247,21 @@ exports.Runtime = Runtime;
 // ConnectionRuntime and SingleConnectionRuntime
 // =============================================================================
 class ConnectionRuntime extends Runtime {
-    constructor({ urlReader, connections, buildManifest, virtualMap, }) {
+    constructor({ urlReader, connections, }) {
         super({
             connections: readers_1.FixedConnectionMap.fromArray(connections),
             urlReader,
-            buildManifest,
-            virtualMap,
         });
         this.rawConnections = connections;
     }
 }
 exports.ConnectionRuntime = ConnectionRuntime;
 class SingleConnectionRuntime extends Runtime {
-    constructor({ urlReader, connection, eventStream, cacheManager, buildManifest, virtualMap, }) {
+    constructor({ urlReader, connection, eventStream, cacheManager, }) {
         super({
             urlReader,
             eventStream,
             cacheManager,
-            buildManifest,
-            virtualMap,
             connection,
         });
         this.connection = connection;

package/dist/connection/registry.d.ts

@@ -48,7 +48,7 @@ export type ConfigValue = string | number | boolean | ValueRef | JsonConfigValue
 /**
  * Type guard for ValueRef.
  */
-export declare function isValueRef(value: ConfigValue): value is ValueRef;
+export declare function isValueRef(value: unknown): value is ValueRef;
 /**
  * Resolve a ValueRef to a string by looking up the environment variable.
  * Returns undefined if the env var is not set.
@@ -106,6 +106,20 @@ export declare function readConnectionsConfig(jsonText: string): ConnectionsConf
  */
 export declare function writeConnectionsConfig(config: ConnectionsConfig): string;
 /**
- * Create a LookupConnection from a ConnectionsConfig using registered factories.
+ * A LookupConnection with lifecycle management: close() shuts down all
+ * cached connections, and an optional onConnectionCreated callback fires
+ * once per connection after factory creation (before caching).
  */
-export declare function createConnectionsFromConfig(config: ConnectionsConfig): LookupConnection<Connection>;
+export interface ManagedConnectionLookup extends LookupConnection<Connection> {
+    close(): Promise<void>;
+}
+/**
+ * Create a ManagedConnectionLookup from a ConnectionsConfig using registered
+ * factories. Connections are cached per name for the lifetime of the returned
+ * object. Call close() to shut down all cached connections.
+ *
+ * @param onConnectionCreated Optional callback invoked once per connection
+ *   immediately after factory creation. Use this for post-creation setup
+ *   (e.g., registering WASM file handlers).
+ */
+export declare function createConnectionsFromConfig(config: ConnectionsConfig, onConnectionCreated?: (name: string, connection: Connection) => void): ManagedConnectionLookup;

package/dist/connection/registry.js

@@ -22,7 +22,8 @@ function isValueRef(value) {
         value !== null &&
         !Array.isArray(value) &&
         Object.keys(value).length === 1 &&
-        'env' in value);
+        'env' in value &&
+        typeof value.env === 'string');
 }
 /**
  * Resolve a ValueRef to a string by looking up the environment variable.
@@ -93,9 +94,15 @@ function writeConnectionsConfig(config) {
     return JSON.stringify(config, null, 2);
 }
 /**
- * Create a LookupConnection from a ConnectionsConfig using registered factories.
+ * Create a ManagedConnectionLookup from a ConnectionsConfig using registered
+ * factories. Connections are cached per name for the lifetime of the returned
+ * object. Call close() to shut down all cached connections.
+ *
+ * @param onConnectionCreated Optional callback invoked once per connection
+ *   immediately after factory creation. Use this for post-creation setup
+ *   (e.g., registering WASM file handlers).
  */
-function createConnectionsFromConfig(config) {
+function createConnectionsFromConfig(config, onConnectionCreated) {
     const entries = Object.entries(config.connections);
     const firstConnectionName = entries.length > 0 ? entries[0][0] : undefined;
     const cache = new Map();
@@ -137,9 +144,19 @@ function createConnectionsFromConfig(config) {
                 }
             }
             const connection = await typeDef.factory(connConfig);
+            if (onConnectionCreated) {
+                onConnectionCreated(connectionName, connection);
+            }
             cache.set(connectionName, connection);
             return connection;
         },
+        async close() {
+            const connections = [...cache.values()];
+            cache.clear();
+            for (const conn of connections) {
+                await conn.close();
+            }
+        },
     };
 }
 //# sourceMappingURL=registry.js.map

package/dist/index.d.ts

@@ -9,8 +9,8 @@ export type { PreparedQuery, Field, AtomicField, ExploreField, QueryField, Sorta
 export type { QueryOptionsReader, RunSQLOptions } from './run_sql_options';
 export type { EventStream, ModelString, ModelURL, QueryString, QueryURL, URLReader, InvalidationKey, } from './runtime_types';
 export type { Connection, ConnectionConfig, ConnectionParameterValue, FetchSchemaOptions, InfoConnection, LookupConnection, PersistSQLResults, PooledConnection, TestableConnection, StreamingConnection, } from './connection/types';
-export { registerConnectionType, getConnectionProperties, getConnectionTypeDisplayName, getRegisteredConnectionTypes, isValueRef, resolveValue, } from './connection/registry';
-export type { ConnectionTypeFactory, ConnectionPropertyType, ConnectionPropertyDefinition, ConnectionTypeDef, ConnectionConfigEntry, ConnectionsConfig, ConfigValue, JsonConfigValue, ValueRef, } from './connection/registry';
+export { registerConnectionType, getConnectionProperties, getConnectionTypeDisplayName, getRegisteredConnectionTypes, createConnectionsFromConfig, isValueRef, resolveValue, } from './connection/registry';
+export type { ConnectionTypeFactory, ConnectionPropertyType, ConnectionPropertyDefinition, ConnectionTypeDef, ConnectionConfigEntry, ConnectionsConfig, ConfigValue, JsonConfigValue, ValueRef, ManagedConnectionLookup, } from './connection/registry';
 export { toAsyncGenerator } from './connection_utils';
 export { modelDefToModelInfo, sourceDefToSourceInfo } from './to_stable';
 export * as API from './api';

package/dist/index.js

@@ -34,7 +34,7 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Malloy = exports.Model = exports.MalloyTranslator = exports.malloyToQuery = exports.constantExprToSQL = exports.isDateUnit = exports.isTimestampUnit = exports.composeSQLExpr = exports.indent = exports.expressionIsUngroupedAggregate = exports.expressionIsScalar = exports.expressionIsCalculation = exports.expressionIsAnalytic = exports.expressionIsAggregate = exports.mkFieldDef = exports.mkArrayDef = exports.isBasicArray = exports.isRepeatedRecord = exports.isSamplingRows = exports.isSamplingPercent = exports.isSamplingEnable = exports.isJoinedSource = exports.isJoined = exports.isCompoundArrayData = exports.isBasicAtomic = exports.isAtomic = exports.isSourceDef = exports.TinyParser = exports.Dialect = exports.spread = exports.literal = exports.variadicParam = exports.param = exports.makeParam = exports.sql = exports.maxScalar = exports.minAggregate = exports.anyExprType = exports.minScalar = exports.overload = exports.qtz = exports.arg = exports.registerDialect = exports.DatabricksDialect = exports.MySQLDialect = exports.SnowflakeDialect = exports.PostgresDialect = exports.TrinoDialect = exports.StandardSQLDialect = exports.DuckDBDialect = void 0;
-exports.makeDigest = exports.EMPTY_BUILD_MANIFEST = exports.PersistSource = exports.annotationToTaglines = exports.annotationToTag = exports.sqlKey = exports.API = exports.sourceDefToSourceInfo = exports.modelDefToModelInfo = exports.toAsyncGenerator = exports.resolveValue = exports.isValueRef = exports.getRegisteredConnectionTypes = exports.getConnectionTypeDisplayName = exports.getConnectionProperties = exports.registerConnectionType = exports.MalloyConfig = exports.Manifest = exports.CacheManager = exports.InMemoryModelCache = exports.Explore = exports.DataWriter = exports.Parse = exports.JSONWriter = exports.CSVWriter = exports.QueryMaterializer = exports.Result = exports.PreparedResult = exports.TimestampTimeframe = exports.DateTimeframe = exports.SourceRelationship = exports.JoinRelationship = exports.MalloyError = exports.FixedConnectionMap = exports.InMemoryURLReader = exports.EmptyURLReader = exports.SingleConnectionRuntime = exports.ConnectionRuntime = exports.AtomicFieldType = exports.Runtime = void 0;
+exports.makeDigest = exports.EMPTY_BUILD_MANIFEST = exports.PersistSource = exports.annotationToTaglines = exports.annotationToTag = exports.sqlKey = exports.API = exports.sourceDefToSourceInfo = exports.modelDefToModelInfo = exports.toAsyncGenerator = exports.resolveValue = exports.isValueRef = exports.createConnectionsFromConfig = exports.getRegisteredConnectionTypes = exports.getConnectionTypeDisplayName = exports.getConnectionProperties = exports.registerConnectionType = exports.MalloyConfig = exports.Manifest = exports.CacheManager = exports.InMemoryModelCache = exports.Explore = exports.DataWriter = exports.Parse = exports.JSONWriter = exports.CSVWriter = exports.QueryMaterializer = exports.Result = exports.PreparedResult = exports.TimestampTimeframe = exports.DateTimeframe = exports.SourceRelationship = exports.JoinRelationship = exports.MalloyError = exports.FixedConnectionMap = exports.InMemoryURLReader = exports.EmptyURLReader = exports.SingleConnectionRuntime = exports.ConnectionRuntime = exports.AtomicFieldType = exports.Runtime = void 0;
 /*
  * Copyright 2023 Google LLC
  *
@@ -143,6 +143,7 @@ Object.defineProperty(exports, "registerConnectionType", { enumerable: true, get
 Object.defineProperty(exports, "getConnectionProperties", { enumerable: true, get: function () { return registry_1.getConnectionProperties; } });
 Object.defineProperty(exports, "getConnectionTypeDisplayName", { enumerable: true, get: function () { return registry_1.getConnectionTypeDisplayName; } });
 Object.defineProperty(exports, "getRegisteredConnectionTypes", { enumerable: true, get: function () { return registry_1.getRegisteredConnectionTypes; } });
+Object.defineProperty(exports, "createConnectionsFromConfig", { enumerable: true, get: function () { return registry_1.createConnectionsFromConfig; } });
 Object.defineProperty(exports, "isValueRef", { enumerable: true, get: function () { return registry_1.isValueRef; } });
 Object.defineProperty(exports, "resolveValue", { enumerable: true, get: function () { return registry_1.resolveValue; } });
 var connection_utils_1 = require("./connection_utils");

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const MALLOY_VERSION = "0.0.364";
+export declare const MALLOY_VERSION = "0.0.366";

package/dist/version.js

@@ -2,5 +2,5 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MALLOY_VERSION = void 0;
 // generated with 'generate-version-file' script; do not edit manually
-exports.MALLOY_VERSION = '0.0.364';
+exports.MALLOY_VERSION = '0.0.366';
 //# sourceMappingURL=version.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@malloydata/malloy",
-  "version": "0.0.364",
+  "version": "0.0.366",
   "license": "MIT",
   "exports": {
     ".": "./dist/index.js",
@@ -47,9 +47,9 @@
     "generate-version-file": "VERSION=$(npm pkg get version --workspaces=false | tr -d \\\")\necho \"// generated with 'generate-version-file' script; do not edit manually\\nexport const MALLOY_VERSION = '$VERSION';\" > src/version.ts"
   },
   "dependencies": {
-    "@malloydata/malloy-filter": "0.0.364",
-    "@malloydata/malloy-interfaces": "0.0.364",
-    "@malloydata/malloy-tag": "0.0.364",
+    "@malloydata/malloy-filter": "0.0.366",
+    "@malloydata/malloy-interfaces": "0.0.366",
+    "@malloydata/malloy-tag": "0.0.366",
     "@noble/hashes": "^1.8.0",
     "antlr4ts": "^0.5.0-alpha.4",
     "assert": "^2.0.0",