@malloydata/malloy 0.0.343 → 0.0.345

package/dist/api/core.js

@@ -500,7 +500,8 @@ function statedCompileQuery(state) {
                     source = query.structRef;
                 }
                 else {
-                    source = result.modelDef.contents[query.structRef];
+                    // TODO: `as StructDef` cast is pre-existing type-safety issue — contents holds NamedModelObject
+                    source = (0, model_1.safeRecordGet)(result.modelDef.contents, query.structRef);
                 }
             }
             const sourceAnnotations = (0, annotation_1.annotationToTaglines)(source.annotation).map(l => ({

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

@@ -1,6 +1,6 @@
 import type { LogMessage } from '../../lang';
 import type { Connection, InfoConnection, LookupConnection, FetchSchemaOptions } from '../../connection/types';
-import type { ConnectionTypeDef, ConnectionPropertyDefinition, ConnectionsConfig } from '../../connection/registry';
+import type { ConnectionTypeDef, ConnectionPropertyDefinition } from '../../connection/registry';
 import type { URLReader, EventStream } from '../../runtime_types';
 import type { SQLSourceDef, QueryRunStats } from '../../model';
 import type { RunSQLOptions } from '../../run_sql_options';
@@ -73,18 +73,6 @@ export declare class Malloy {
      * Get the names of all registered connection types.
      */
     static getRegisteredConnectionTypes(): string[];
-    /**
-     * Parse a JSON config string into an editable ConnectionsConfig.
-     */
-    static readConnectionsConfig(jsonText: string): ConnectionsConfig;
-    /**
-     * Serialize a ConnectionsConfig to a JSON string.
-     */
-    static writeConnectionsConfig(config: ConnectionsConfig): string;
-    /**
-     * Create a LookupConnection from a ConnectionsConfig using registered factories.
-     */
-    static createConnectionsFromConfig(config: ConnectionsConfig): LookupConnection<Connection>;
     private static _parse;
     /**
      * Parse a Malloy document by URL.

package/dist/api/foundation/compile.js

@@ -69,24 +69,6 @@ class Malloy {
     static getRegisteredConnectionTypes() {
         return (0, registry_1.getRegisteredConnectionTypes)();
     }
-    /**
-     * Parse a JSON config string into an editable ConnectionsConfig.
-     */
-    static readConnectionsConfig(jsonText) {
-        return (0, registry_1.readConnectionsConfig)(jsonText);
-    }
-    /**
-     * Serialize a ConnectionsConfig to a JSON string.
-     */
-    static writeConnectionsConfig(config) {
-        return (0, registry_1.writeConnectionsConfig)(config);
-    }
-    /**
-     * Create a LookupConnection from a ConnectionsConfig using registered factories.
-     */
-    static createConnectionsFromConfig(config) {
-        return (0, registry_1.createConnectionsFromConfig)(config);
-    }
     static _parse(source, url, eventStream, options, invalidationKey) {
         if (url === undefined) {
             url = new URL(MALLOY_INTERNAL_URL);

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

@@ -0,0 +1,116 @@
+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';
+/**
+ * The parsed contents of a malloy-config.json file.
+ */
+export interface MalloyProjectConfig {
+    connections?: Record<string, ConnectionConfigEntry>;
+    manifestPath?: string;
+}
+/**
+ * In-memory manifest store. Reads, updates, and serializes manifest data.
+ *
+ * Always valid — starts empty, call load() to populate from a file.
+ * The internal BuildManifest object is stable: load() and update() mutate
+ * the same object, so any reference obtained via `buildManifest` stays current.
+ */
+export declare class Manifest {
+    private readonly _urlReader?;
+    private readonly _data;
+    private readonly _touched;
+    constructor(urlReader?: URLReader);
+    /**
+     * Load manifest data from a manifest root directory.
+     * Reads `<manifestRoot>/malloy-manifest.json` via the URLReader.
+     * Replaces any existing data. If the file doesn't exist or no URLReader
+     * is available, clears to empty.
+     */
+    load(manifestRoot: URL): Promise<void>;
+    /**
+     * Load manifest data from a JSON string.
+     * Replaces any existing data.
+     */
+    loadText(jsonText: string): void;
+    /**
+     * The live BuildManifest. This is a stable reference — load() and update()
+     * mutate the same object, so passing this to a Runtime means the Runtime
+     * always sees current data.
+     */
+    get buildManifest(): BuildManifest;
+    /**
+     * Add or replace a manifest entry. Also marks it as touched.
+     */
+    update(buildId: BuildID, entry: BuildManifestEntry): void;
+    /**
+     * Mark an existing entry as active without changing it.
+     * Use this for entries that already exist and don't need rebuilding.
+     */
+    touch(buildId: BuildID): void;
+    /**
+     * Returns only entries that were update()d or touch()ed.
+     * This is the manifest a builder should write — it reflects
+     * exactly what the current build references.
+     */
+    get activeEntries(): BuildManifest;
+}
+/**
+ * Loads and holds a Malloy project configuration (connections + manifest).
+ *
+ * Two construction modes:
+ *
+ *   // From a URL — reads config + manifest via URLReader
+ *   const config = new MalloyConfig(urlReader, configURL);
+ *   await config.load();
+ *
+ *   // 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,
+ *   });
+ */
+export declare class MalloyConfig {
+    private readonly _urlReader?;
+    private readonly _configURL?;
+    private _data;
+    private _connectionMap;
+    private readonly _manifest;
+    constructor(configText: string);
+    constructor(urlReader: URLReader, configURL: string);
+    /**
+     * Load everything: parse config file, then load the default manifest.
+     * No-op if created from text.
+     */
+    load(): Promise<void>;
+    /**
+     * Load only the config file. Does not load the manifest.
+     * No-op if created from text.
+     */
+    loadConfig(): Promise<void>;
+    /**
+     * The parsed config data. Undefined if created from URL and not yet loaded.
+     */
+    get data(): MalloyProjectConfig | undefined;
+    /**
+     * The active connection entries. Set this to override which connections
+     * are used before constructing a Runtime.
+     */
+    get connectionMap(): Record<string, ConnectionConfigEntry> | undefined;
+    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.
+     */
+    get connections(): LookupConnection<Connection>;
+    /**
+     * The Manifest object. Always exists, may be empty if not yet loaded.
+     */
+    get manifest(): Manifest;
+}

package/dist/api/foundation/config.js

@@ -0,0 +1,211 @@
+"use strict";
+/*
+ * Copyright Contributors to the Malloy project
+ * SPDX-License-Identifier: MIT
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MalloyConfig = exports.Manifest = void 0;
+const registry_1 = require("../../connection/registry");
+const DEFAULT_MANIFEST_PATH = 'MANIFESTS';
+const MANIFEST_FILENAME = 'malloy-manifest.json';
+/**
+ * In-memory manifest store. Reads, updates, and serializes manifest data.
+ *
+ * Always valid — starts empty, call load() to populate from a file.
+ * The internal BuildManifest object is stable: load() and update() mutate
+ * the same object, so any reference obtained via `buildManifest` stays current.
+ */
+class Manifest {
+    constructor(urlReader) {
+        this._data = {};
+        this._touched = new Set();
+        this._urlReader = urlReader;
+    }
+    /**
+     * Load manifest data from a manifest root directory.
+     * Reads `<manifestRoot>/malloy-manifest.json` via the URLReader.
+     * Replaces any existing data. If the file doesn't exist or no URLReader
+     * is available, clears to empty.
+     */
+    async load(manifestRoot) {
+        // Clear existing entries and touched set
+        for (const key of Object.keys(this._data)) {
+            delete this._data[key];
+        }
+        this._touched.clear();
+        if (!this._urlReader)
+            return;
+        const dir = manifestRoot.toString().endsWith('/')
+            ? manifestRoot.toString()
+            : manifestRoot.toString() + '/';
+        const manifestURL = new URL(MANIFEST_FILENAME, dir);
+        let contents;
+        try {
+            const result = await this._urlReader.readURL(manifestURL);
+            contents = typeof result === 'string' ? result : result.contents;
+        }
+        catch {
+            // No manifest file — stay empty
+            return;
+        }
+        const loaded = JSON.parse(contents);
+        Object.assign(this._data, loaded);
+    }
+    /**
+     * Load manifest data from a JSON string.
+     * Replaces any existing data.
+     */
+    loadText(jsonText) {
+        for (const key of Object.keys(this._data)) {
+            delete this._data[key];
+        }
+        this._touched.clear();
+        const loaded = JSON.parse(jsonText);
+        Object.assign(this._data, loaded);
+    }
+    /**
+     * The live BuildManifest. This is a stable reference — load() and update()
+     * mutate the same object, so passing this to a Runtime means the Runtime
+     * always sees current data.
+     */
+    get buildManifest() {
+        return this._data;
+    }
+    /**
+     * Add or replace a manifest entry. Also marks it as touched.
+     */
+    update(buildId, entry) {
+        this._data[buildId] = entry;
+        this._touched.add(buildId);
+    }
+    /**
+     * Mark an existing entry as active without changing it.
+     * Use this for entries that already exist and don't need rebuilding.
+     */
+    touch(buildId) {
+        this._touched.add(buildId);
+    }
+    /**
+     * Returns only entries that were update()d or touch()ed.
+     * This is the manifest a builder should write — it reflects
+     * exactly what the current build references.
+     */
+    get activeEntries() {
+        const result = {};
+        for (const id of this._touched) {
+            if (this._data[id]) {
+                result[id] = this._data[id];
+            }
+        }
+        return result;
+    }
+}
+exports.Manifest = Manifest;
+/**
+ * Loads and holds a Malloy project configuration (connections + manifest).
+ *
+ * Two construction modes:
+ *
+ *   // From a URL — reads config + manifest via URLReader
+ *   const config = new MalloyConfig(urlReader, configURL);
+ *   await config.load();
+ *
+ *   // 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,
+ *   });
+ */
+class MalloyConfig {
+    constructor(urlReaderOrText, configURL) {
+        if (typeof urlReaderOrText === 'string') {
+            this._data = parseConfigText(urlReaderOrText);
+            this._connectionMap = this._data.connections
+                ? { ...this._data.connections }
+                : undefined;
+            this._manifest = new Manifest();
+        }
+        else {
+            this._urlReader = urlReaderOrText;
+            this._configURL = configURL;
+            this._manifest = new Manifest(urlReaderOrText);
+        }
+    }
+    /**
+     * Load everything: parse config file, then load the default manifest.
+     * No-op if created from text.
+     */
+    async load() {
+        var _a, _b;
+        await this.loadConfig();
+        if (this._configURL) {
+            const manifestPath = (_b = (_a = this._data) === null || _a === void 0 ? void 0 : _a.manifestPath) !== null && _b !== void 0 ? _b : DEFAULT_MANIFEST_PATH;
+            const manifestRoot = new URL(manifestPath, this._configURL);
+            await this._manifest.load(manifestRoot);
+        }
+    }
+    /**
+     * Load only the config file. Does not load the manifest.
+     * No-op if created from text.
+     */
+    async loadConfig() {
+        if (!this._urlReader || !this._configURL)
+            return;
+        const result = await this._urlReader.readURL(new URL(this._configURL));
+        const contents = typeof result === 'string' ? result : result.contents;
+        this._data = parseConfigText(contents);
+        this._connectionMap = this._data.connections
+            ? { ...this._data.connections }
+            : undefined;
+    }
+    /**
+     * The parsed config data. Undefined if created from URL and not yet loaded.
+     */
+    get data() {
+        return this._data;
+    }
+    /**
+     * The active connection entries. Set this to override which connections
+     * are used before constructing a Runtime.
+     */
+    get connectionMap() {
+        return this._connectionMap;
+    }
+    set connectionMap(map) {
+        this._connectionMap = map;
+    }
+    /**
+     * 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.
+     */
+    get connections() {
+        if (!this._connectionMap) {
+            throw new Error('Config not loaded. Call load() or loadConfig() first.');
+        }
+        return (0, registry_1.createConnectionsFromConfig)({ connections: this._connectionMap });
+    }
+    /**
+     * The Manifest object. Always exists, may be empty if not yet loaded.
+     */
+    get manifest() {
+        return this._manifest;
+    }
+}
+exports.MalloyConfig = MalloyConfig;
+/**
+ * Parse a config JSON string into a MalloyProjectConfig.
+ * Invalid connection entries (missing `is`) are silently dropped.
+ */
+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 };
+}
+//# sourceMappingURL=config.js.map

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

@@ -1,5 +1,5 @@
 import type { LogMessage } from '../../lang';
-import type { BuildID, CompiledQuery, DocumentLocation, BooleanFieldDef, JSONFieldDef, NumberFieldDef, StringFieldDef, FilterCondition, Query as InternalQuery, ModelDef, DocumentPosition as ModelDocumentPosition, NamedQueryDef, StructDef, TurtleDef, NativeUnsupportedFieldDef, ImportLocation, Annotation, AtomicFieldDef, DateFieldDef, ATimestampFieldDef, SourceDef, Argument, SourceComponentInfo, DocumentReference, PersistableSourceDef } from '../../model';
+import type { BuildID, CompiledQuery, DocumentLocation, BooleanFieldDef, JSONFieldDef, NumberFieldDef, StringFieldDef, FilterCondition, Query as InternalQuery, ModelDef, DocumentPosition as ModelDocumentPosition, NamedQueryDef, StructDef, TurtleDef, NativeUnsupportedFieldDef, ImportLocation, Annotation, NamedModelObject, AtomicFieldDef, DateFieldDef, ATimestampFieldDef, SourceDef, Argument, SourceComponentInfo, DocumentReference, PersistableSourceDef } from '../../model';
 import { QueryModel } from '../../model';
 import type { Dialect } from '../../dialect';
 import type { BuildGraph, CompileQueryOptions } from './types';
@@ -235,7 +235,10 @@ export declare class Model implements Taggable {
     readonly fromSources: string[];
     private readonly references;
     private _queryModel?;
+    private readonly contentsMap;
     constructor(modelDef: ModelDef, problems: LogMessage[], fromSources: string[], existingQueryModel?: QueryModel);
+    /** Safe lookup in model contents by name. */
+    getContent(name: string): NamedModelObject | undefined;
     get queryModel(): QueryModel;
     /**
      * Returns the cached QueryModel if it exists, without creating one.

package/dist/api/foundation/core.js

@@ -750,6 +750,11 @@ class Model {
         this.fromSources = fromSources;
         this.references = new reference_list_1.ReferenceList((_a = fromSources[0]) !== null && _a !== void 0 ? _a : '', (_b = modelDef.references) !== null && _b !== void 0 ? _b : []);
         this._queryModel = existingQueryModel;
+        this.contentsMap = new Map(Object.entries(modelDef.contents));
+    }
+    /** Safe lookup in model contents by name. */
+    getContent(name) {
+        return this.contentsMap.get(name);
     }
     get queryModel() {
         if (!this._queryModel) {
@@ -799,7 +804,7 @@ class Model {
      * @return A prepared query.
      */
     getPreparedQueryByName(queryName) {
-        const query = this.modelDef.contents[queryName];
+        const query = this.getContent(queryName);
         if ((query === null || query === void 0 ? void 0 : query.type) === 'query') {
             return new PreparedQuery(query, this, this.problems, queryName);
         }
@@ -846,7 +851,7 @@ class Model {
      * @return An `Explore`.
      */
     getExploreByName(name) {
-        const struct = this.modelDef.contents[name];
+        const struct = this.getContent(name);
         if (struct && (0, model_1.isSourceDef)(struct)) {
             return new Explore(struct);
         }
@@ -1129,9 +1134,9 @@ class PreparedQuery {
     get dialect() {
         const sourceRef = this._query.structRef;
         const source = typeof sourceRef === 'string'
-            ? this._modelDef.contents[sourceRef]
+            ? this._model.getContent(sourceRef)
             : sourceRef;
-        if (!(0, model_1.isSourceDef)(source)) {
+        if (source === undefined || !(0, model_1.isSourceDef)(source)) {
             throw new Error('Invalid source for query');
         }
         return source.dialect;
@@ -1221,7 +1226,7 @@ class PreparedResult {
     }
     get sourceExplore() {
         const name = this.inner.sourceExplore;
-        const explore = this.modelDef.contents[name];
+        const explore = (0, model_1.safeRecordGet)(this.modelDef.contents, name);
         if (explore && (0, model_1.isSourceDef)(explore)) {
             return new Explore(explore);
         }

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

@@ -7,4 +7,5 @@ export { SourceRelationship, AtomicFieldType, DateTimeframe, TimestampTimeframe,
 export { type ResultJSON, type DataColumn, type DataArrayOrRecord, Result, DataArray, DataRecord, } from './result';
 export { type WriteStream, DataWriter, JSONWriter, CSVWriter } from './writers';
 export { Runtime, ConnectionRuntime, SingleConnectionRuntime, ModelMaterializer, QueryMaterializer, PreparedResultMaterializer, ExploreMaterializer, } from './runtime';
+export { Manifest, MalloyConfig } from './config';
 export { Malloy, MalloyError, type MalloyCompileOptions, type MalloyRunOptions, } from './compile';

package/dist/api/foundation/index.js

@@ -4,8 +4,8 @@
  * SPDX-License-Identifier: MIT
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Malloy = exports.ExploreMaterializer = exports.PreparedResultMaterializer = exports.QueryMaterializer = exports.ModelMaterializer = exports.SingleConnectionRuntime = exports.ConnectionRuntime = exports.Runtime = exports.CSVWriter = exports.JSONWriter = exports.DataWriter = exports.DataRecord = exports.DataArray = exports.Result = exports.PreparedResult = exports.PreparedQuery = exports.PersistSource = exports.Model = exports.QueryField = exports.Query = exports.StringField = exports.UnsupportedField = exports.JSONField = exports.BooleanField = exports.NumberField = exports.TimestampField = exports.DateField = exports.AtomicField = exports.ExploreField = exports.Explore = exports.JoinRelationship = exports.TimestampTimeframe = exports.DateTimeframe = exports.AtomicFieldType = exports.SourceRelationship = exports.DocumentCompletion = exports.DocumentSymbol = exports.DocumentPosition = exports.DocumentRange = exports.DocumentTablePath = exports.Parse = exports.InMemoryModelCache = exports.CacheManager = exports.getInvalidationKey = exports.readURL = exports.isInternalURL = exports.hashForInvalidationKey = exports.FixedConnectionMap = exports.InMemoryURLReader = exports.EmptyURLReader = void 0;
-exports.MalloyError = void 0;
+exports.Manifest = exports.ExploreMaterializer = exports.PreparedResultMaterializer = exports.QueryMaterializer = exports.ModelMaterializer = exports.SingleConnectionRuntime = exports.ConnectionRuntime = exports.Runtime = exports.CSVWriter = exports.JSONWriter = exports.DataWriter = exports.DataRecord = exports.DataArray = exports.Result = exports.PreparedResult = exports.PreparedQuery = exports.PersistSource = exports.Model = exports.QueryField = exports.Query = exports.StringField = exports.UnsupportedField = exports.JSONField = exports.BooleanField = exports.NumberField = exports.TimestampField = exports.DateField = exports.AtomicField = exports.ExploreField = exports.Explore = exports.JoinRelationship = exports.TimestampTimeframe = exports.DateTimeframe = exports.AtomicFieldType = exports.SourceRelationship = exports.DocumentCompletion = exports.DocumentSymbol = exports.DocumentPosition = exports.DocumentRange = exports.DocumentTablePath = exports.Parse = exports.InMemoryModelCache = exports.CacheManager = exports.getInvalidationKey = exports.readURL = exports.isInternalURL = exports.hashForInvalidationKey = exports.FixedConnectionMap = exports.InMemoryURLReader = exports.EmptyURLReader = void 0;
+exports.MalloyError = exports.Malloy = exports.MalloyConfig = void 0;
 // URL readers and connection helpers
 var readers_1 = require("./readers");
 Object.defineProperty(exports, "EmptyURLReader", { enumerable: true, get: function () { return readers_1.EmptyURLReader; } });
@@ -70,6 +70,10 @@ Object.defineProperty(exports, "ModelMaterializer", { enumerable: true, get: fun
 Object.defineProperty(exports, "QueryMaterializer", { enumerable: true, get: function () { return runtime_1.QueryMaterializer; } });
 Object.defineProperty(exports, "PreparedResultMaterializer", { enumerable: true, get: function () { return runtime_1.PreparedResultMaterializer; } });
 Object.defineProperty(exports, "ExploreMaterializer", { enumerable: true, get: function () { return runtime_1.ExploreMaterializer; } });
+// Config and Manifest
+var config_1 = require("./config");
+Object.defineProperty(exports, "Manifest", { enumerable: true, get: function () { return config_1.Manifest; } });
+Object.defineProperty(exports, "MalloyConfig", { enumerable: true, get: function () { return config_1.MalloyConfig; } });
 // Compile (Malloy static class)
 var compile_1 = require("./compile");
 Object.defineProperty(exports, "Malloy", { enumerable: true, get: function () { return compile_1.Malloy; } });

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

@@ -1,6 +1,6 @@
 import type { Connection, LookupConnection } from '../../connection/types';
 import type { URLReader, EventStream } from '../../runtime_types';
-import type { ModelDef, Query as InternalQuery, SearchIndexResult, SearchValueMapResult, QueryRunStats } from '../../model';
+import type { ModelDef, Query as InternalQuery, SearchIndexResult, SearchValueMapResult, QueryRunStats, BuildManifest } from '../../model';
 import type { Dialect } from '../../dialect';
 import type { RunSQLOptions } from '../../run_sql_options';
 import type { CacheManager } from './cache';
@@ -39,10 +39,12 @@ export declare class Runtime {
     private _connections;
     private _eventStream;
     private _cacheManager;
-    constructor({ urlReader, connections, connection, eventStream, cacheManager, }: {
+    private _buildManifest;
+    constructor({ urlReader, connections, connection, eventStream, cacheManager, buildManifest, }: {
         urlReader?: URLReader;
         eventStream?: EventStream;
         cacheManager?: CacheManager;
+        buildManifest?: BuildManifest;
     } & Connectionable);
     /**
      * @return The `CacheManager` for this runtime instance.
@@ -60,6 +62,14 @@ export declare class Runtime {
      * @return The `EventStream` for this runtime instance.
      */
     get eventStream(): EventStream | undefined;
+    /**
+     * The build manifest for persist source substitution.
+     * When set, compiled queries automatically resolve persist sources
+     * against this manifest. Can be overridden per-query via
+     * CompileQueryOptions.buildManifest.
+     */
+    get buildManifest(): BuildManifest | undefined;
+    set buildManifest(manifest: BuildManifest | undefined);
     /**
      * Load a Malloy model by URL or contents.
      *
@@ -132,17 +142,19 @@ export declare class Runtime {
 }
 export declare class ConnectionRuntime extends Runtime {
     readonly rawConnections: Connection[];
-    constructor({ urlReader, connections, }: {
+    constructor({ urlReader, connections, buildManifest, }: {
         urlReader?: URLReader;
         connections: Connection[];
+        buildManifest?: BuildManifest;
     });
 }
 export declare class SingleConnectionRuntime<T extends Connection = Connection> extends Runtime {
     readonly connection: T;
-    constructor({ urlReader, connection, eventStream, cacheManager, }: {
+    constructor({ urlReader, connection, eventStream, cacheManager, buildManifest, }: {
         urlReader?: URLReader;
         eventStream?: EventStream;
         cacheManager?: CacheManager;
+        buildManifest?: BuildManifest;
         connection: T;
     });
     get supportsNesting(): boolean;

package/dist/api/foundation/runtime.js

@@ -46,7 +46,7 @@ class FluentState {
  * An environment for compiling and running Malloy queries.
  */
 class Runtime {
-    constructor({ urlReader, connections, connection, eventStream, cacheManager, }) {
+    constructor({ urlReader, connections, connection, eventStream, cacheManager, buildManifest, }) {
         this.isTestRuntime = false;
         if (connections === undefined) {
             if (connection === undefined) {
@@ -63,6 +63,7 @@ class Runtime {
         this._connections = connections;
         this._eventStream = eventStream;
         this._cacheManager = cacheManager;
+        this._buildManifest = buildManifest;
     }
     /**
      * @return The `CacheManager` for this runtime instance.
@@ -88,6 +89,18 @@ class Runtime {
     get eventStream() {
         return this._eventStream;
     }
+    /**
+     * The build manifest for persist source substitution.
+     * When set, compiled queries automatically resolve persist sources
+     * against this manifest. Can be overridden per-query via
+     * CompileQueryOptions.buildManifest.
+     */
+    get buildManifest() {
+        return this._buildManifest;
+    }
+    set buildManifest(manifest) {
+        this._buildManifest = manifest;
+    }
     /**
      * Load a Malloy model by URL or contents.
      *
@@ -210,21 +223,23 @@ exports.Runtime = Runtime;
 // ConnectionRuntime and SingleConnectionRuntime
 // =============================================================================
 class ConnectionRuntime extends Runtime {
-    constructor({ urlReader, connections, }) {
+    constructor({ urlReader, connections, buildManifest, }) {
         super({
             connections: readers_1.FixedConnectionMap.fromArray(connections),
             urlReader,
+            buildManifest,
         });
         this.rawConnections = connections;
     }
 }
 exports.ConnectionRuntime = ConnectionRuntime;
 class SingleConnectionRuntime extends Runtime {
-    constructor({ urlReader, connection, eventStream, cacheManager, }) {
+    constructor({ urlReader, connection, eventStream, cacheManager, buildManifest, }) {
         super({
             urlReader,
             eventStream,
             cacheManager,
+            buildManifest,
             connection,
         });
         this.connection = connection;
@@ -554,17 +569,21 @@ class QueryMaterializer extends FluentState {
      */
     loadPreparedResult(options) {
         return this.makePreparedResultMaterializer(async () => {
+            var _a;
             const preparedQuery = await this.materialize();
             const mergedOptions = {
                 eventStream: this.eventStream,
                 ...this.compileQueryOptions,
                 ...options,
             };
-            // If buildManifest is provided, compute connectionDigests for manifest lookups
+            // Use manifest from options if provided, otherwise fall back to Runtime's manifest.
+            // Pass an empty {} in options to explicitly suppress manifest substitution.
+            const buildManifest = (_a = mergedOptions.buildManifest) !== null && _a !== void 0 ? _a : this.runtime.buildManifest;
+            // If we have a manifest, compute connectionDigests for manifest lookups
             // TODO: This is inefficient - we call getBuildPlan just to find connection names.
             // Consider adding a listConnections() method to LookupConnection, or caching this.
             let connectionDigests;
-            if (mergedOptions.buildManifest) {
+            if (buildManifest) {
                 // Require experimental.persistence compiler flag to use buildManifest
                 const modelTag = preparedQuery.model.tagParse({ prefix: /^##! / }).tag;
                 if (!modelTag.has('experimental', 'persistence')) {
@@ -572,7 +591,7 @@ class QueryMaterializer extends FluentState {
                 }
                 const plan = preparedQuery.model.getBuildPlan();
                 const connectionNames = new Set(Object.values(plan.sources).map(s => s.connectionName));
-                connectionDigests = {};
+                connectionDigests = (0, model_1.mkSafeRecord)();
                 for (const connName of connectionNames) {
                     const conn = await this.runtime.connections.lookupConnection(connName);
                     connectionDigests[connName] = conn.getDigest();
@@ -581,7 +600,7 @@ class QueryMaterializer extends FluentState {
             // Build PrepareResultOptions from CompileQueryOptions + connectionDigests
             const prepareResultOptions = {
                 defaultRowLimit: mergedOptions.defaultRowLimit,
-                buildManifest: mergedOptions.buildManifest,
+                buildManifest,
                 connectionDigests,
                 strictPersist: mergedOptions.strictPersist,
             };

package/dist/connection/registry.d.ts

@@ -54,6 +54,10 @@ export interface ConnectionConfigEntry {
     is: string;
     [key: string]: ConfigValue;
 }
+/**
+ * Type guard for ConnectionConfigEntry.
+ */
+export declare function isConnectionConfigEntry(value: unknown): value is ConnectionConfigEntry;
 /**
  * The editable intermediate representation of a connections config file.
  */
@@ -87,7 +91,7 @@ export declare function getConnectionTypeDisplayName(typeName: string): string |
 export declare function getRegisteredConnectionTypes(): string[];
 /**
  * Parse a JSON config string into a ConnectionsConfig.
- * Validates that each connection entry has an `is` field.
+ * Entries without a valid `is` field are silently dropped.
  */
 export declare function readConnectionsConfig(jsonText: string): ConnectionsConfig;
 /**