@malloy-publisher/server 0.0.238 → 0.0.239

package/dist/server.mjs

@@ -239314,7 +239314,7 @@ var require_yauzl = __commonJS((exports) => {
   exports.ZipFile = ZipFile;
   exports.Entry = Entry;
   exports.RandomAccessReader = RandomAccessReader;
-  function open2(path4, options, callback) {
+  function open2(path5, options, callback) {
     if (typeof options === "function") {
       callback = options;
       options = null;
@@ -239333,7 +239333,7 @@ var require_yauzl = __commonJS((exports) => {
       options.strictFileNames = false;
     if (callback == null)
       callback = defaultCallback;
-    fs4.open(path4, "r", function(err, fd) {
+    fs4.open(path5, "r", function(err, fd) {
       if (err)
         return callback(err);
       fromFd(fd, options, function(err2, zipfile) {
@@ -239997,7 +239997,7 @@ var require_extract_zip = __commonJS((exports, module) => {
   var debug = require_src5()("extract-zip");
   var { createWriteStream, promises: fs4 } = __require("fs");
   var getStream = require_get_stream();
-  var path4 = __require("path");
+  var path5 = __require("path");
   var { promisify } = __require("util");
   var stream4 = __require("stream");
   var yauzl = require_yauzl();
@@ -240035,12 +240035,12 @@ var require_extract_zip = __commonJS((exports, module) => {
             this.zipfile.readEntry();
             return;
           }
-          const destDir = path4.dirname(path4.join(this.opts.dir, entry.fileName));
+          const destDir = path5.dirname(path5.join(this.opts.dir, entry.fileName));
           try {
             await fs4.mkdir(destDir, { recursive: true });
             const canonicalDestDir = await fs4.realpath(destDir);
-            const relativeDestDir = path4.relative(this.opts.dir, canonicalDestDir);
-            if (relativeDestDir.split(path4.sep).includes("..")) {
+            const relativeDestDir = path5.relative(this.opts.dir, canonicalDestDir);
+            if (relativeDestDir.split(path5.sep).includes("..")) {
               throw new Error(`Out of bound path "${canonicalDestDir}" found while processing file ${entry.fileName}`);
             }
             await this.extractEntry(entry);
@@ -240062,7 +240062,7 @@ var require_extract_zip = __commonJS((exports, module) => {
       if (this.opts.onEntry) {
         this.opts.onEntry(entry, this.zipfile);
       }
-      const dest = path4.join(this.opts.dir, entry.fileName);
+      const dest = path5.join(this.opts.dir, entry.fileName);
       const mode = entry.externalFileAttributes >> 16 & 65535;
       const IFMT = 61440;
       const IFDIR = 16384;
@@ -240077,7 +240077,7 @@ var require_extract_zip = __commonJS((exports, module) => {
         isDir = madeBy === 0 && entry.externalFileAttributes === 16;
       debug("extracting entry", { filename: entry.fileName, isDir, isSymlink: symlink });
       const procMode = this.getExtractedMode(mode, isDir) & 511;
-      const destDir = isDir ? dest : path4.dirname(dest);
+      const destDir = isDir ? dest : path5.dirname(dest);
       const mkdirOptions = { recursive: true };
       if (isDir) {
         mkdirOptions.mode = procMode;
@@ -240120,7 +240120,7 @@ var require_extract_zip = __commonJS((exports, module) => {
   }
   module.exports = async function(zipPath, opts) {
     debug("creating target directory", opts.dir);
-    if (!path4.isAbsolute(opts.dir)) {
+    if (!path5.isAbsolute(opts.dir)) {
       throw new Error("Target directory is expected to be absolute");
     }
     await fs4.mkdir(opts.dir, { recursive: true });
@@ -240138,10 +240138,10 @@ var require_src122 = __commonJS((exports) => {
   var fs_1 = __require("fs");
   var debug_1 = __importDefault(require_src5());
   var log = debug_1.default("@kwsites/file-exists");
-  function check(path4, isFile2, isDirectory) {
-    log(`checking %s`, path4);
+  function check(path5, isFile2, isDirectory) {
+    log(`checking %s`, path5);
     try {
-      const stat4 = fs_1.statSync(path4);
+      const stat4 = fs_1.statSync(path5);
       if (stat4.isFile() && isFile2) {
         log(`[OK] path represents a file`);
         return true;
@@ -240161,8 +240161,8 @@ var require_src122 = __commonJS((exports) => {
       throw e;
     }
   }
-  function exists(path4, type = exports.READABLE) {
-    return check(path4, (type & exports.FILE) > 0, (type & exports.FOLDER) > 0);
+  function exists(path5, type = exports.READABLE) {
+    return check(path5, (type & exports.FILE) > 0, (type & exports.FOLDER) > 0);
   }
   exports.exists = exists;
   exports.FILE = 1;
@@ -240938,14 +240938,14 @@ var require_brace_expansion = __commonJS((exports, module) => {
 var require_minimatch = __commonJS((exports, module) => {
   module.exports = minimatch;
   minimatch.Minimatch = Minimatch;
-  var path6 = function() {
+  var path7 = function() {
     try {
       return __require("path");
     } catch (e) {}
   }() || {
     sep: "/"
   };
-  minimatch.sep = path6.sep;
+  minimatch.sep = path7.sep;
   var GLOBSTAR = minimatch.GLOBSTAR = Minimatch.GLOBSTAR = {};
   var expand = require_brace_expansion();
   var plTypes = {
@@ -241036,8 +241036,8 @@ var require_minimatch = __commonJS((exports, module) => {
     if (!options)
       options = {};
     pattern = pattern.trim();
-    if (!options.allowWindowsEscape && path6.sep !== "/") {
-      pattern = pattern.split(path6.sep).join("/");
+    if (!options.allowWindowsEscape && path7.sep !== "/") {
+      pattern = pattern.split(path7.sep).join("/");
     }
     this.options = options;
     this.set = [];
@@ -241414,8 +241414,8 @@ var require_minimatch = __commonJS((exports, module) => {
     if (f === "/" && partial)
       return true;
     var options = this.options;
-    if (path6.sep !== "/") {
-      f = f.split(path6.sep).join("/");
+    if (path7.sep !== "/") {
+      f = f.split(path7.sep).join("/");
     }
     f = f.split(slashSplit);
     this.debug(this.pattern, "split", f);
@@ -241526,9 +241526,9 @@ var require_recursive_readdir = __commonJS((exports, module) => {
   var p = __require("path");
   var minimatch = require_minimatch();
   function patternMatcher(pattern) {
-    return function(path6, stats) {
+    return function(path7, stats) {
       var minimatcher = new minimatch.Minimatch(pattern, { matchBase: true });
-      return (!minimatcher.negate || stats.isFile()) && minimatcher.match(path6);
+      return (!minimatcher.negate || stats.isFile()) && minimatcher.match(path7);
     };
   }
   function toMatcherFunction(ignoreEntry) {
@@ -241538,14 +241538,14 @@ var require_recursive_readdir = __commonJS((exports, module) => {
       return patternMatcher(ignoreEntry);
     }
   }
-  function readdir3(path6, ignores, callback) {
+  function readdir3(path7, ignores, callback) {
     if (typeof ignores == "function") {
       callback = ignores;
       ignores = [];
     }
     if (!callback) {
       return new Promise(function(resolve4, reject) {
-        readdir3(path6, ignores || [], function(err, data) {
+        readdir3(path7, ignores || [], function(err, data) {
           if (err) {
             reject(err);
           } else {
@@ -241556,7 +241556,7 @@ var require_recursive_readdir = __commonJS((exports, module) => {
     }
     ignores = ignores.map(toMatcherFunction);
     var list = [];
-    fs6.readdir(path6, function(err, files) {
+    fs6.readdir(path7, function(err, files) {
       if (err) {
         return callback(err);
       }
@@ -241565,7 +241565,7 @@ var require_recursive_readdir = __commonJS((exports, module) => {
         return callback(null, list);
       }
       files.forEach(function(file) {
-        var filePath = p.join(path6, file);
+        var filePath = p.join(path7, file);
         fs6.stat(filePath, function(_err, stats) {
           if (_err) {
             return callback(_err);
@@ -248883,8 +248883,8 @@ var require_uri_all = __commonJS((exports, module) => {
           wsComponents.secure = undefined;
         }
         if (wsComponents.resourceName) {
-          var _wsComponents$resourc = wsComponents.resourceName.split("?"), _wsComponents$resourc2 = slicedToArray(_wsComponents$resourc, 2), path11 = _wsComponents$resourc2[0], query = _wsComponents$resourc2[1];
-          wsComponents.path = path11 && path11 !== "/" ? path11 : undefined;
+          var _wsComponents$resourc = wsComponents.resourceName.split("?"), _wsComponents$resourc2 = slicedToArray(_wsComponents$resourc, 2), path12 = _wsComponents$resourc2[0], query = _wsComponents$resourc2[1];
+          wsComponents.path = path12 && path12 !== "/" ? path12 : undefined;
           wsComponents.query = query;
           wsComponents.resourceName = undefined;
         }
@@ -249277,12 +249277,12 @@ var require_util12 = __commonJS((exports, module) => {
     return "'" + escapeQuotes(str) + "'";
   }
   function getPathExpr(currentPath, expr, jsonPointers, isNumber2) {
-    var path11 = jsonPointers ? "'/' + " + expr + (isNumber2 ? "" : ".replace(/~/g, '~0').replace(/\\//g, '~1')") : isNumber2 ? "'[' + " + expr + " + ']'" : "'[\\'' + " + expr + " + '\\']'";
-    return joinPaths(currentPath, path11);
+    var path12 = jsonPointers ? "'/' + " + expr + (isNumber2 ? "" : ".replace(/~/g, '~0').replace(/\\//g, '~1')") : isNumber2 ? "'[' + " + expr + " + ']'" : "'[\\'' + " + expr + " + '\\']'";
+    return joinPaths(currentPath, path12);
   }
   function getPath(currentPath, prop, jsonPointers) {
-    var path11 = jsonPointers ? toQuotedString("/" + escapeJsonPointer(prop)) : toQuotedString(getProperty(prop));
-    return joinPaths(currentPath, path11);
+    var path12 = jsonPointers ? toQuotedString("/" + escapeJsonPointer(prop)) : toQuotedString(getProperty(prop));
+    return joinPaths(currentPath, path12);
   }
   var JSON_POINTER = /^\/(?:[^~]|~0|~1)*$/;
   var RELATIVE_JSON_POINTER = /^([0-9]+)(#|\/(?:[^~]|~0|~1)*)?$/;
@@ -261231,7 +261231,7 @@ var import_cors = __toESM(require_lib7(), 1);
 var import_express = __toESM(require_express(), 1);
 var import_http_proxy_middleware = __toESM(require_dist4(), 1);
 import * as http2 from "http";
-import * as path13 from "path";
+import * as path14 from "path";
 import { fileURLToPath as fileURLToPath7 } from "url";
 
 // src/controller/compile.controller.ts
@@ -269195,10 +269195,12 @@ class ModelController {
 // src/controller/package.controller.ts
 init_constants();
 init_errors();
+import * as path4 from "path";
 function formatPublishRejections(pkg, exploresOverride) {
   const message = [
     pkg.formatInvalidExplores(exploresOverride),
     pkg.formatInvalidPersistencePolicy(),
+    pkg.formatInvalidIncrementalPolicy(),
     pkg.formatPersistenceCollisionRejections()
   ].filter(Boolean).join(`
 `);
@@ -269299,7 +269301,7 @@ class PackageController {
     } else if (packageLocation.startsWith("s3://")) {
       await this.environmentStore.downloadS3Directory(packageLocation, environmentName, targetPath, isCompressedFile);
     }
-    if (packageLocation.startsWith("/")) {
+    if (packageLocation.startsWith("/") || path4.isAbsolute(packageLocation)) {
       await this.environmentStore.mountLocalDirectory(packageLocation, targetPath, environmentName, packageName);
     }
   }
@@ -269446,7 +269448,7 @@ class ReaddirpStream extends Readable2 {
     this._directoryFilter = normalizeFilter(opts.directoryFilter);
     const statMethod = opts.lstat ? lstat : stat;
     if (wantBigintFsStats) {
-      this._stat = (path4) => statMethod(path4, { bigint: true });
+      this._stat = (path5) => statMethod(path5, { bigint: true });
     } else {
       this._stat = statMethod;
     }
@@ -269471,8 +269473,8 @@ class ReaddirpStream extends Readable2 {
         const par = this.parent;
         const fil = par && par.files;
         if (fil && fil.length > 0) {
-          const { path: path4, depth } = par;
-          const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path4));
+          const { path: path5, depth } = par;
+          const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path5));
           const awaited = await Promise.all(slice);
           for (const entry of awaited) {
             if (!entry)
@@ -269512,20 +269514,20 @@ class ReaddirpStream extends Readable2 {
       this.reading = false;
     }
   }
-  async _exploreDir(path4, depth) {
+  async _exploreDir(path5, depth) {
     let files;
     try {
-      files = await readdir(path4, this._rdOptions);
+      files = await readdir(path5, this._rdOptions);
     } catch (error) {
       this._onError(error);
     }
-    return { files, depth, path: path4 };
+    return { files, depth, path: path5 };
   }
-  async _formatEntry(dirent, path4) {
+  async _formatEntry(dirent, path5) {
     let entry;
     const basename = this._isDirent ? dirent.name : dirent;
     try {
-      const fullPath = presolve(pjoin(path4, basename));
+      const fullPath = presolve(pjoin(path5, basename));
       entry = { path: prelative(this._root, fullPath), fullPath, basename };
       entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
     } catch (err) {
@@ -269924,16 +269926,16 @@ var delFromSet = (main, prop, item) => {
 };
 var isEmptySet = (val) => val instanceof Set ? val.size === 0 : !val;
 var FsWatchInstances = new Map;
-function createFsWatchInstance(path4, options, listener, errHandler, emitRaw) {
+function createFsWatchInstance(path5, options, listener, errHandler, emitRaw) {
   const handleEvent = (rawEvent, evPath) => {
-    listener(path4);
-    emitRaw(rawEvent, evPath, { watchedPath: path4 });
-    if (evPath && path4 !== evPath) {
-      fsWatchBroadcast(sysPath.resolve(path4, evPath), KEY_LISTENERS, sysPath.join(path4, evPath));
+    listener(path5);
+    emitRaw(rawEvent, evPath, { watchedPath: path5 });
+    if (evPath && path5 !== evPath) {
+      fsWatchBroadcast(sysPath.resolve(path5, evPath), KEY_LISTENERS, sysPath.join(path5, evPath));
     }
   };
   try {
-    return fs_watch(path4, {
+    return fs_watch(path5, {
       persistent: options.persistent
     }, handleEvent);
   } catch (error) {
@@ -269949,12 +269951,12 @@ var fsWatchBroadcast = (fullPath, listenerType, val1, val2, val3) => {
     listener(val1, val2, val3);
   });
 };
-var setFsWatchListener = (path4, fullPath, options, handlers) => {
+var setFsWatchListener = (path5, fullPath, options, handlers) => {
   const { listener, errHandler, rawEmitter } = handlers;
   let cont = FsWatchInstances.get(fullPath);
   let watcher;
   if (!options.persistent) {
-    watcher = createFsWatchInstance(path4, options, listener, errHandler, rawEmitter);
+    watcher = createFsWatchInstance(path5, options, listener, errHandler, rawEmitter);
     if (!watcher)
       return;
     return watcher.close.bind(watcher);
@@ -269964,7 +269966,7 @@ var setFsWatchListener = (path4, fullPath, options, handlers) => {
     addAndConvert(cont, KEY_ERR, errHandler);
     addAndConvert(cont, KEY_RAW, rawEmitter);
   } else {
-    watcher = createFsWatchInstance(path4, options, fsWatchBroadcast.bind(null, fullPath, KEY_LISTENERS), errHandler, fsWatchBroadcast.bind(null, fullPath, KEY_RAW));
+    watcher = createFsWatchInstance(path5, options, fsWatchBroadcast.bind(null, fullPath, KEY_LISTENERS), errHandler, fsWatchBroadcast.bind(null, fullPath, KEY_RAW));
     if (!watcher)
       return;
     watcher.on(EV.ERROR, async (error) => {
@@ -269973,7 +269975,7 @@ var setFsWatchListener = (path4, fullPath, options, handlers) => {
         cont.watcherUnusable = true;
       if (isWindows && error.code === "EPERM") {
         try {
-          const fd = await open(path4, "r");
+          const fd = await open(path5, "r");
           await fd.close();
           broadcastErr(error);
         } catch (err) {}
@@ -270003,7 +270005,7 @@ var setFsWatchListener = (path4, fullPath, options, handlers) => {
   };
 };
 var FsWatchFileInstances = new Map;
-var setFsWatchFileListener = (path4, fullPath, options, handlers) => {
+var setFsWatchFileListener = (path5, fullPath, options, handlers) => {
   const { listener, rawEmitter } = handlers;
   let cont = FsWatchFileInstances.get(fullPath);
   const copts = cont && cont.options;
@@ -270025,7 +270027,7 @@ var setFsWatchFileListener = (path4, fullPath, options, handlers) => {
         });
         const currmtime = curr.mtimeMs;
         if (curr.size !== prev.size || currmtime > prev.mtimeMs || currmtime === 0) {
-          foreach(cont.listeners, (listener2) => listener2(path4, curr));
+          foreach(cont.listeners, (listener2) => listener2(path5, curr));
         }
       })
     };
@@ -270048,13 +270050,13 @@ class NodeFsHandler {
     this.fsw = fsW;
     this._boundHandleError = (error) => fsW._handleError(error);
   }
-  _watchWithNodeFs(path4, listener) {
+  _watchWithNodeFs(path5, listener) {
     const opts = this.fsw.options;
-    const directory = sysPath.dirname(path4);
-    const basename2 = sysPath.basename(path4);
+    const directory = sysPath.dirname(path5);
+    const basename2 = sysPath.basename(path5);
     const parent = this.fsw._getWatchedDir(directory);
     parent.add(basename2);
-    const absolutePath = sysPath.resolve(path4);
+    const absolutePath = sysPath.resolve(path5);
     const options = {
       persistent: opts.persistent
     };
@@ -270064,12 +270066,12 @@ class NodeFsHandler {
     if (opts.usePolling) {
       const enableBin = opts.interval !== opts.binaryInterval;
       options.interval = enableBin && isBinaryPath(basename2) ? opts.binaryInterval : opts.interval;
-      closer = setFsWatchFileListener(path4, absolutePath, options, {
+      closer = setFsWatchFileListener(path5, absolutePath, options, {
         listener,
         rawEmitter: this.fsw._emitRaw
       });
     } else {
-      closer = setFsWatchListener(path4, absolutePath, options, {
+      closer = setFsWatchListener(path5, absolutePath, options, {
         listener,
         errHandler: this._boundHandleError,
         rawEmitter: this.fsw._emitRaw
@@ -270087,7 +270089,7 @@ class NodeFsHandler {
     let prevStats = stats;
     if (parent.has(basename2))
       return;
-    const listener = async (path4, newStats) => {
+    const listener = async (path5, newStats) => {
       if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file, 5))
         return;
       if (!newStats || newStats.mtimeMs === 0) {
@@ -270101,11 +270103,11 @@ class NodeFsHandler {
             this.fsw._emit(EV.CHANGE, file, newStats2);
           }
           if ((isMacos || isLinux || isFreeBSD) && prevStats.ino !== newStats2.ino) {
-            this.fsw._closeFile(path4);
+            this.fsw._closeFile(path5);
             prevStats = newStats2;
             const closer2 = this._watchWithNodeFs(file, listener);
             if (closer2)
-              this.fsw._addPathCloser(path4, closer2);
+              this.fsw._addPathCloser(path5, closer2);
           } else {
             prevStats = newStats2;
           }
@@ -270129,7 +270131,7 @@ class NodeFsHandler {
     }
     return closer;
   }
-  async _handleSymlink(entry, directory, path4, item) {
+  async _handleSymlink(entry, directory, path5, item) {
     if (this.fsw.closed) {
       return;
     }
@@ -270139,7 +270141,7 @@ class NodeFsHandler {
       this.fsw._incrReadyCount();
       let linkPath;
       try {
-        linkPath = await fsrealpath(path4);
+        linkPath = await fsrealpath(path5);
       } catch (e) {
         this.fsw._emitReady();
         return true;
@@ -270149,12 +270151,12 @@ class NodeFsHandler {
       if (dir.has(item)) {
         if (this.fsw._symlinkPaths.get(full) !== linkPath) {
           this.fsw._symlinkPaths.set(full, linkPath);
-          this.fsw._emit(EV.CHANGE, path4, entry.stats);
+          this.fsw._emit(EV.CHANGE, path5, entry.stats);
         }
       } else {
         dir.add(item);
         this.fsw._symlinkPaths.set(full, linkPath);
-        this.fsw._emit(EV.ADD, path4, entry.stats);
+        this.fsw._emit(EV.ADD, path5, entry.stats);
       }
       this.fsw._emitReady();
       return true;
@@ -270183,9 +270185,9 @@ class NodeFsHandler {
         return;
       }
       const item = entry.path;
-      let path4 = sysPath.join(directory, item);
+      let path5 = sysPath.join(directory, item);
       current.add(item);
-      if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path4, item)) {
+      if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path5, item)) {
         return;
       }
       if (this.fsw.closed) {
@@ -270194,8 +270196,8 @@ class NodeFsHandler {
       }
       if (item === target || !target && !previous.has(item)) {
         this.fsw._incrReadyCount();
-        path4 = sysPath.join(dir, sysPath.relative(dir, path4));
-        this._addToNodeFs(path4, initialAdd, wh, depth + 1);
+        path5 = sysPath.join(dir, sysPath.relative(dir, path5));
+        this._addToNodeFs(path5, initialAdd, wh, depth + 1);
       }
     }).on(EV.ERROR, this._boundHandleError);
     return new Promise((resolve3, reject) => {
@@ -270244,13 +270246,13 @@ class NodeFsHandler {
     }
     return closer;
   }
-  async _addToNodeFs(path4, initialAdd, priorWh, depth, target) {
+  async _addToNodeFs(path5, initialAdd, priorWh, depth, target) {
     const ready = this.fsw._emitReady;
-    if (this.fsw._isIgnored(path4) || this.fsw.closed) {
+    if (this.fsw._isIgnored(path5) || this.fsw.closed) {
       ready();
       return false;
     }
-    const wh = this.fsw._getWatchHelpers(path4);
+    const wh = this.fsw._getWatchHelpers(path5);
     if (priorWh) {
       wh.filterPath = (entry) => priorWh.filterPath(entry);
       wh.filterDir = (entry) => priorWh.filterDir(entry);
@@ -270266,8 +270268,8 @@ class NodeFsHandler {
       const follow = this.fsw.options.followSymlinks;
       let closer;
       if (stats.isDirectory()) {
-        const absPath = sysPath.resolve(path4);
-        const targetPath = follow ? await fsrealpath(path4) : path4;
+        const absPath = sysPath.resolve(path5);
+        const targetPath = follow ? await fsrealpath(path5) : path5;
         if (this.fsw.closed)
           return;
         closer = await this._handleDir(wh.watchPath, stats, initialAdd, depth, target, wh, targetPath);
@@ -270277,29 +270279,29 @@ class NodeFsHandler {
           this.fsw._symlinkPaths.set(absPath, targetPath);
         }
       } else if (stats.isSymbolicLink()) {
-        const targetPath = follow ? await fsrealpath(path4) : path4;
+        const targetPath = follow ? await fsrealpath(path5) : path5;
         if (this.fsw.closed)
           return;
         const parent = sysPath.dirname(wh.watchPath);
         this.fsw._getWatchedDir(parent).add(wh.watchPath);
         this.fsw._emit(EV.ADD, wh.watchPath, stats);
-        closer = await this._handleDir(parent, stats, initialAdd, depth, path4, wh, targetPath);
+        closer = await this._handleDir(parent, stats, initialAdd, depth, path5, wh, targetPath);
         if (this.fsw.closed)
           return;
         if (targetPath !== undefined) {
-          this.fsw._symlinkPaths.set(sysPath.resolve(path4), targetPath);
+          this.fsw._symlinkPaths.set(sysPath.resolve(path5), targetPath);
         }
       } else {
         closer = this._handleFile(wh.watchPath, stats, initialAdd);
       }
       ready();
       if (closer)
-        this.fsw._addPathCloser(path4, closer);
+        this.fsw._addPathCloser(path5, closer);
       return false;
     } catch (error) {
       if (this.fsw._handleError(error)) {
         ready();
-        return path4;
+        return path5;
       }
     }
   }
@@ -270343,26 +270345,26 @@ function createPattern(matcher) {
   }
   return () => false;
 }
-function normalizePath(path4) {
-  if (typeof path4 !== "string")
+function normalizePath(path5) {
+  if (typeof path5 !== "string")
     throw new Error("string expected");
-  path4 = sysPath2.normalize(path4);
-  path4 = path4.replace(/\\/g, "/");
+  path5 = sysPath2.normalize(path5);
+  path5 = path5.replace(/\\/g, "/");
   let prepend = false;
-  if (path4.startsWith("//"))
+  if (path5.startsWith("//"))
     prepend = true;
   const DOUBLE_SLASH_RE2 = /\/\//;
-  while (path4.match(DOUBLE_SLASH_RE2))
-    path4 = path4.replace(DOUBLE_SLASH_RE2, "/");
+  while (path5.match(DOUBLE_SLASH_RE2))
+    path5 = path5.replace(DOUBLE_SLASH_RE2, "/");
   if (prepend)
-    path4 = "/" + path4;
-  return path4;
+    path5 = "/" + path5;
+  return path5;
 }
 function matchPatterns(patterns, testString, stats) {
-  const path4 = normalizePath(testString);
+  const path5 = normalizePath(testString);
   for (let index = 0;index < patterns.length; index++) {
     const pattern = patterns[index];
-    if (pattern(path4, stats)) {
+    if (pattern(path5, stats)) {
       return true;
     }
   }
@@ -270402,19 +270404,19 @@ var toUnix = (string) => {
   }
   return str;
 };
-var normalizePathToUnix = (path4) => toUnix(sysPath2.normalize(toUnix(path4)));
-var normalizeIgnored = (cwd = "") => (path4) => {
-  if (typeof path4 === "string") {
-    return normalizePathToUnix(sysPath2.isAbsolute(path4) ? path4 : sysPath2.join(cwd, path4));
+var normalizePathToUnix = (path5) => toUnix(sysPath2.normalize(toUnix(path5)));
+var normalizeIgnored = (cwd = "") => (path5) => {
+  if (typeof path5 === "string") {
+    return normalizePathToUnix(sysPath2.isAbsolute(path5) ? path5 : sysPath2.join(cwd, path5));
   } else {
-    return path4;
+    return path5;
   }
 };
-var getAbsolutePath = (path4, cwd) => {
-  if (sysPath2.isAbsolute(path4)) {
-    return path4;
+var getAbsolutePath = (path5, cwd) => {
+  if (sysPath2.isAbsolute(path5)) {
+    return path5;
   }
-  return sysPath2.join(cwd, path4);
+  return sysPath2.join(cwd, path5);
 };
 var EMPTY_SET = Object.freeze(new Set);
 
@@ -270471,10 +270473,10 @@ var STAT_METHOD_F = "stat";
 var STAT_METHOD_L = "lstat";
 
 class WatchHelper {
-  constructor(path4, follow, fsw) {
+  constructor(path5, follow, fsw) {
     this.fsw = fsw;
-    const watchPath = path4;
-    this.path = path4 = path4.replace(REPLACER_RE, "");
+    const watchPath = path5;
+    this.path = path5 = path5.replace(REPLACER_RE, "");
     this.watchPath = watchPath;
     this.fullWatchPath = sysPath2.resolve(watchPath);
     this.dirParts = [];
@@ -270587,20 +270589,20 @@ class FSWatcher extends EventEmitter2 {
     this._closePromise = undefined;
     let paths = unifyPaths(paths_);
     if (cwd) {
-      paths = paths.map((path4) => {
-        const absPath = getAbsolutePath(path4, cwd);
+      paths = paths.map((path5) => {
+        const absPath = getAbsolutePath(path5, cwd);
         return absPath;
       });
     }
-    paths.forEach((path4) => {
-      this._removeIgnoredPath(path4);
+    paths.forEach((path5) => {
+      this._removeIgnoredPath(path5);
     });
     this._userIgnored = undefined;
     if (!this._readyCount)
       this._readyCount = 0;
     this._readyCount += paths.length;
-    Promise.all(paths.map(async (path4) => {
-      const res = await this._nodeFsHandler._addToNodeFs(path4, !_internal, undefined, 0, _origAdd);
+    Promise.all(paths.map(async (path5) => {
+      const res = await this._nodeFsHandler._addToNodeFs(path5, !_internal, undefined, 0, _origAdd);
       if (res)
         this._emitReady();
       return res;
@@ -270619,17 +270621,17 @@ class FSWatcher extends EventEmitter2 {
       return this;
     const paths = unifyPaths(paths_);
     const { cwd } = this.options;
-    paths.forEach((path4) => {
-      if (!sysPath2.isAbsolute(path4) && !this._closers.has(path4)) {
+    paths.forEach((path5) => {
+      if (!sysPath2.isAbsolute(path5) && !this._closers.has(path5)) {
         if (cwd)
-          path4 = sysPath2.join(cwd, path4);
-        path4 = sysPath2.resolve(path4);
+          path5 = sysPath2.join(cwd, path5);
+        path5 = sysPath2.resolve(path5);
       }
-      this._closePath(path4);
-      this._addIgnoredPath(path4);
-      if (this._watched.has(path4)) {
+      this._closePath(path5);
+      this._addIgnoredPath(path5);
+      if (this._watched.has(path5)) {
         this._addIgnoredPath({
-          path: path4,
+          path: path5,
           recursive: true
         });
       }
@@ -270678,38 +270680,38 @@ class FSWatcher extends EventEmitter2 {
     if (event !== EVENTS.ERROR)
       this.emit(EVENTS.ALL, event, ...args);
   }
-  async _emit(event, path4, stats) {
+  async _emit(event, path5, stats) {
     if (this.closed)
       return;
     const opts = this.options;
     if (isWindows)
-      path4 = sysPath2.normalize(path4);
+      path5 = sysPath2.normalize(path5);
     if (opts.cwd)
-      path4 = sysPath2.relative(opts.cwd, path4);
-    const args = [path4];
+      path5 = sysPath2.relative(opts.cwd, path5);
+    const args = [path5];
     if (stats != null)
       args.push(stats);
     const awf = opts.awaitWriteFinish;
     let pw;
-    if (awf && (pw = this._pendingWrites.get(path4))) {
+    if (awf && (pw = this._pendingWrites.get(path5))) {
       pw.lastChange = new Date;
       return this;
     }
     if (opts.atomic) {
       if (event === EVENTS.UNLINK) {
-        this._pendingUnlinks.set(path4, [event, ...args]);
+        this._pendingUnlinks.set(path5, [event, ...args]);
         setTimeout(() => {
-          this._pendingUnlinks.forEach((entry, path5) => {
+          this._pendingUnlinks.forEach((entry, path6) => {
             this.emit(...entry);
             this.emit(EVENTS.ALL, ...entry);
-            this._pendingUnlinks.delete(path5);
+            this._pendingUnlinks.delete(path6);
           });
         }, typeof opts.atomic === "number" ? opts.atomic : 100);
         return this;
       }
-      if (event === EVENTS.ADD && this._pendingUnlinks.has(path4)) {
+      if (event === EVENTS.ADD && this._pendingUnlinks.has(path5)) {
         event = EVENTS.CHANGE;
-        this._pendingUnlinks.delete(path4);
+        this._pendingUnlinks.delete(path5);
       }
     }
     if (awf && (event === EVENTS.ADD || event === EVENTS.CHANGE) && this._readyEmitted) {
@@ -270727,16 +270729,16 @@ class FSWatcher extends EventEmitter2 {
           this.emitWithAll(event, args);
         }
       };
-      this._awaitWriteFinish(path4, awf.stabilityThreshold, event, awfEmit);
+      this._awaitWriteFinish(path5, awf.stabilityThreshold, event, awfEmit);
       return this;
     }
     if (event === EVENTS.CHANGE) {
-      const isThrottled = !this._throttle(EVENTS.CHANGE, path4, 50);
+      const isThrottled = !this._throttle(EVENTS.CHANGE, path5, 50);
       if (isThrottled)
         return this;
     }
     if (opts.alwaysStat && stats === undefined && (event === EVENTS.ADD || event === EVENTS.ADD_DIR || event === EVENTS.CHANGE)) {
-      const fullPath = opts.cwd ? sysPath2.join(opts.cwd, path4) : path4;
+      const fullPath = opts.cwd ? sysPath2.join(opts.cwd, path5) : path5;
       let stats2;
       try {
         stats2 = await stat3(fullPath);
@@ -270755,23 +270757,23 @@ class FSWatcher extends EventEmitter2 {
     }
     return error || this.closed;
   }
-  _throttle(actionType, path4, timeout) {
+  _throttle(actionType, path5, timeout) {
     if (!this._throttled.has(actionType)) {
       this._throttled.set(actionType, new Map);
     }
     const action = this._throttled.get(actionType);
     if (!action)
       throw new Error("invalid throttle");
-    const actionPath = action.get(path4);
+    const actionPath = action.get(path5);
     if (actionPath) {
       actionPath.count++;
       return false;
     }
     let timeoutObject;
     const clear = () => {
-      const item = action.get(path4);
+      const item = action.get(path5);
       const count = item ? item.count : 0;
-      action.delete(path4);
+      action.delete(path5);
       clearTimeout(timeoutObject);
       if (item)
         clearTimeout(item.timeoutObject);
@@ -270779,50 +270781,50 @@ class FSWatcher extends EventEmitter2 {
     };
     timeoutObject = setTimeout(clear, timeout);
     const thr = { timeoutObject, clear, count: 0 };
-    action.set(path4, thr);
+    action.set(path5, thr);
     return thr;
   }
   _incrReadyCount() {
     return this._readyCount++;
   }
-  _awaitWriteFinish(path4, threshold, event, awfEmit) {
+  _awaitWriteFinish(path5, threshold, event, awfEmit) {
     const awf = this.options.awaitWriteFinish;
     if (typeof awf !== "object")
       return;
     const pollInterval = awf.pollInterval;
     let timeoutHandler;
-    let fullPath = path4;
-    if (this.options.cwd && !sysPath2.isAbsolute(path4)) {
-      fullPath = sysPath2.join(this.options.cwd, path4);
+    let fullPath = path5;
+    if (this.options.cwd && !sysPath2.isAbsolute(path5)) {
+      fullPath = sysPath2.join(this.options.cwd, path5);
     }
     const now = new Date;
     const writes = this._pendingWrites;
     function awaitWriteFinishFn(prevStat) {
       statcb(fullPath, (err, curStat) => {
-        if (err || !writes.has(path4)) {
+        if (err || !writes.has(path5)) {
           if (err && err.code !== "ENOENT")
             awfEmit(err);
           return;
         }
         const now2 = Number(new Date);
         if (prevStat && curStat.size !== prevStat.size) {
-          writes.get(path4).lastChange = now2;
+          writes.get(path5).lastChange = now2;
         }
-        const pw = writes.get(path4);
+        const pw = writes.get(path5);
         const df = now2 - pw.lastChange;
         if (df >= threshold) {
-          writes.delete(path4);
+          writes.delete(path5);
           awfEmit(undefined, curStat);
         } else {
           timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval, curStat);
         }
       });
     }
-    if (!writes.has(path4)) {
-      writes.set(path4, {
+    if (!writes.has(path5)) {
+      writes.set(path5, {
         lastChange: now,
         cancelWait: () => {
-          writes.delete(path4);
+          writes.delete(path5);
           clearTimeout(timeoutHandler);
           return event;
         }
@@ -270830,8 +270832,8 @@ class FSWatcher extends EventEmitter2 {
       timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval);
     }
   }
-  _isIgnored(path4, stats) {
-    if (this.options.atomic && DOT_RE.test(path4))
+  _isIgnored(path5, stats) {
+    if (this.options.atomic && DOT_RE.test(path5))
       return true;
     if (!this._userIgnored) {
       const { cwd } = this.options;
@@ -270841,13 +270843,13 @@ class FSWatcher extends EventEmitter2 {
       const list = [...ignoredPaths.map(normalizeIgnored(cwd)), ...ignored];
       this._userIgnored = anymatch(list, undefined);
     }
-    return this._userIgnored(path4, stats);
+    return this._userIgnored(path5, stats);
   }
-  _isntIgnored(path4, stat4) {
-    return !this._isIgnored(path4, stat4);
+  _isntIgnored(path5, stat4) {
+    return !this._isIgnored(path5, stat4);
   }
-  _getWatchHelpers(path4) {
-    return new WatchHelper(path4, this.options.followSymlinks, this);
+  _getWatchHelpers(path5) {
+    return new WatchHelper(path5, this.options.followSymlinks, this);
   }
   _getWatchedDir(directory) {
     const dir = sysPath2.resolve(directory);
@@ -270861,57 +270863,57 @@ class FSWatcher extends EventEmitter2 {
     return Boolean(Number(stats.mode) & 256);
   }
   _remove(directory, item, isDirectory) {
-    const path4 = sysPath2.join(directory, item);
-    const fullPath = sysPath2.resolve(path4);
-    isDirectory = isDirectory != null ? isDirectory : this._watched.has(path4) || this._watched.has(fullPath);
-    if (!this._throttle("remove", path4, 100))
+    const path5 = sysPath2.join(directory, item);
+    const fullPath = sysPath2.resolve(path5);
+    isDirectory = isDirectory != null ? isDirectory : this._watched.has(path5) || this._watched.has(fullPath);
+    if (!this._throttle("remove", path5, 100))
       return;
     if (!isDirectory && this._watched.size === 1) {
       this.add(directory, item, true);
     }
-    const wp = this._getWatchedDir(path4);
+    const wp = this._getWatchedDir(path5);
     const nestedDirectoryChildren = wp.getChildren();
-    nestedDirectoryChildren.forEach((nested) => this._remove(path4, nested));
+    nestedDirectoryChildren.forEach((nested) => this._remove(path5, nested));
     const parent = this._getWatchedDir(directory);
     const wasTracked = parent.has(item);
     parent.remove(item);
     if (this._symlinkPaths.has(fullPath)) {
       this._symlinkPaths.delete(fullPath);
     }
-    let relPath = path4;
+    let relPath = path5;
     if (this.options.cwd)
-      relPath = sysPath2.relative(this.options.cwd, path4);
+      relPath = sysPath2.relative(this.options.cwd, path5);
     if (this.options.awaitWriteFinish && this._pendingWrites.has(relPath)) {
       const event = this._pendingWrites.get(relPath).cancelWait();
       if (event === EVENTS.ADD)
         return;
     }
-    this._watched.delete(path4);
+    this._watched.delete(path5);
     this._watched.delete(fullPath);
     const eventName = isDirectory ? EVENTS.UNLINK_DIR : EVENTS.UNLINK;
-    if (wasTracked && !this._isIgnored(path4))
-      this._emit(eventName, path4);
-    this._closePath(path4);
+    if (wasTracked && !this._isIgnored(path5))
+      this._emit(eventName, path5);
+    this._closePath(path5);
   }
-  _closePath(path4) {
-    this._closeFile(path4);
-    const dir = sysPath2.dirname(path4);
-    this._getWatchedDir(dir).remove(sysPath2.basename(path4));
+  _closePath(path5) {
+    this._closeFile(path5);
+    const dir = sysPath2.dirname(path5);
+    this._getWatchedDir(dir).remove(sysPath2.basename(path5));
   }
-  _closeFile(path4) {
-    const closers = this._closers.get(path4);
+  _closeFile(path5) {
+    const closers = this._closers.get(path5);
     if (!closers)
       return;
     closers.forEach((closer) => closer());
-    this._closers.delete(path4);
+    this._closers.delete(path5);
   }
-  _addPathCloser(path4, closer) {
+  _addPathCloser(path5, closer) {
     if (!closer)
       return;
-    let list = this._closers.get(path4);
+    let list = this._closers.get(path5);
     if (!list) {
       list = [];
-      this._closers.set(path4, list);
+      this._closers.set(path5, list);
     }
     list.push(closer);
   }
@@ -270944,7 +270946,7 @@ var esm_default = { watch, FSWatcher };
 init_errors();
 init_logger();
 import { EventEmitter as EventEmitter4 } from "events";
-import path10 from "path";
+import path11 from "path";
 
 // src/service/environment_store.ts
 var import_client_s33 = __toESM(require_dist_cjs75(), 1);
@@ -271281,7 +271283,7 @@ var import_extract_zip = __toESM(require_extract_zip(), 1);
 import crypto5 from "crypto";
 import * as fs9 from "fs";
 import * as os2 from "os";
-import * as path9 from "path";
+import * as path10 from "path";
 
 // ../../node_modules/simple-git/dist/esm/index.js
 var import_file_exists = __toESM(require_dist12(), 1);
@@ -271319,8 +271321,8 @@ function pathspec(...paths) {
   cache.set(key, paths);
   return key;
 }
-function isPathSpec(path4) {
-  return path4 instanceof String && cache.has(path4);
+function isPathSpec(path5) {
+  return path5 instanceof String && cache.has(path5);
 }
 function toPaths(pathSpec) {
   return cache.get(pathSpec) || [];
@@ -271406,8 +271408,8 @@ function toLinesWithContent(input = "", trimmed2 = true, separator = `
 function forEachLineWithContent(input, callback) {
   return toLinesWithContent(input, true).map((line) => callback(line));
 }
-function folderExists(path4) {
-  return import_file_exists.exists(path4, import_file_exists.FOLDER);
+function folderExists(path5) {
+  return import_file_exists.exists(path5, import_file_exists.FOLDER);
 }
 function append2(target, item) {
   if (Array.isArray(target)) {
@@ -271788,8 +271790,8 @@ function checkIsRepoRootTask() {
     commands,
     format: "utf-8",
     onError,
-    parser(path4) {
-      return /^\.(git)?$/.test(path4.trim());
+    parser(path5) {
+      return /^\.(git)?$/.test(path5.trim());
     }
   };
 }
@@ -272200,11 +272202,11 @@ function parseGrep(grep) {
   const paths = /* @__PURE__ */ new Set;
   const results = {};
   forEachLineWithContent(grep, (input) => {
-    const [path4, line, preview] = input.split(NULL);
-    paths.add(path4);
-    (results[path4] = results[path4] || []).push({
+    const [path5, line, preview] = input.split(NULL);
+    paths.add(path5);
+    (results[path5] = results[path5] || []).push({
       line: asNumber(line),
-      path: path4,
+      path: path5,
       preview
     });
   });
@@ -272866,14 +272868,14 @@ var init_hash_object = __esm2({
     init_task();
   }
 });
-function parseInit(bare, path4, text) {
+function parseInit(bare, path5, text) {
   const response = String(text).trim();
   let result;
   if (result = initResponseRegex.exec(response)) {
-    return new InitSummary(bare, path4, false, result[1]);
+    return new InitSummary(bare, path5, false, result[1]);
   }
   if (result = reInitResponseRegex.exec(response)) {
-    return new InitSummary(bare, path4, true, result[1]);
+    return new InitSummary(bare, path5, true, result[1]);
   }
   let gitDir = "";
   const tokens = response.split(" ");
@@ -272884,7 +272886,7 @@ function parseInit(bare, path4, text) {
       break;
     }
   }
-  return new InitSummary(bare, path4, /^re/i.test(response), gitDir);
+  return new InitSummary(bare, path5, /^re/i.test(response), gitDir);
 }
 var InitSummary;
 var initResponseRegex;
@@ -272892,9 +272894,9 @@ var reInitResponseRegex;
 var init_InitSummary = __esm2({
   "src/lib/responses/InitSummary.ts"() {
     InitSummary = class {
-      constructor(bare, path4, existing, gitDir) {
+      constructor(bare, path5, existing, gitDir) {
         this.bare = bare;
-        this.path = path4;
+        this.path = path5;
         this.existing = existing;
         this.gitDir = gitDir;
       }
@@ -272906,7 +272908,7 @@ var init_InitSummary = __esm2({
 function hasBareCommand(command) {
   return command.includes(bareCommand);
 }
-function initTask(bare = false, path4, customArgs) {
+function initTask(bare = false, path5, customArgs) {
   const commands = ["init", ...customArgs];
   if (bare && !hasBareCommand(commands)) {
     commands.splice(1, 0, bareCommand);
@@ -272915,7 +272917,7 @@ function initTask(bare = false, path4, customArgs) {
     commands,
     format: "utf-8",
     parser(text) {
-      return parseInit(commands.includes("--bare"), path4, text);
+      return parseInit(commands.includes("--bare"), path5, text);
     }
   };
 }
@@ -273630,12 +273632,12 @@ var init_FileStatusSummary = __esm2({
   "src/lib/responses/FileStatusSummary.ts"() {
     fromPathRegex = /^(.+)\0(.+)$/;
     FileStatusSummary = class {
-      constructor(path4, index, working_dir) {
-        this.path = path4;
+      constructor(path5, index, working_dir) {
+        this.path = path5;
         this.index = index;
         this.working_dir = working_dir;
         if (index === "R" || working_dir === "R") {
-          const detail = fromPathRegex.exec(path4) || [null, path4, path4];
+          const detail = fromPathRegex.exec(path5) || [null, path5, path5];
           this.from = detail[2] || "";
           this.path = detail[1] || "";
         }
@@ -273666,14 +273668,14 @@ function splitLine(result, lineStr) {
     default:
       return;
   }
-  function data(index, workingDir, path4) {
+  function data(index, workingDir, path5) {
     const raw = `${index}${workingDir}`;
     const handler = parsers6.get(raw);
     if (handler) {
-      handler(result, path4);
+      handler(result, path5);
     }
     if (raw !== "##" && raw !== "!!") {
-      result.files.push(new FileStatusSummary(path4, index, workingDir));
+      result.files.push(new FileStatusSummary(path5, index, workingDir));
     }
   }
 }
@@ -273904,8 +273906,8 @@ var init_simple_git_api = __esm2({
         }
         return this._runTask(configurationErrorTask("Git.cwd: workingDirectory must be supplied as a string"), next);
       }
-      hashObject(path4, write) {
-        return this._runTask(hashObjectTask(path4, write === true), trailingFunctionArgument(arguments));
+      hashObject(path5, write) {
+        return this._runTask(hashObjectTask(path5, write === true), trailingFunctionArgument(arguments));
       }
       init(bare) {
         return this._runTask(initTask(bare === true, this._executor.cwd, getTrailingOptions(arguments)), trailingFunctionArgument(arguments));
@@ -274482,8 +274484,8 @@ __export2(sub_module_exports, {
   subModuleTask: () => subModuleTask,
   updateSubModuleTask: () => updateSubModuleTask
 });
-function addSubModuleTask(repo, path4) {
-  return subModuleTask(["add", repo, path4]);
+function addSubModuleTask(repo, path5) {
+  return subModuleTask(["add", repo, path5]);
 }
 function initSubModuleTask(customArgs) {
   return subModuleTask(["init", ...customArgs]);
@@ -274751,8 +274753,8 @@ var require_git = __commonJS2({
       }
       return this._runTask(straightThroughStringTask2(command, this._trimmed), next);
     };
-    Git2.prototype.submoduleAdd = function(repo, path4, then) {
-      return this._runTask(addSubModuleTask2(repo, path4), trailingFunctionArgument2(arguments));
+    Git2.prototype.submoduleAdd = function(repo, path5, then) {
+      return this._runTask(addSubModuleTask2(repo, path5), trailingFunctionArgument2(arguments));
     };
     Git2.prototype.submoduleUpdate = function(args, then) {
       return this._runTask(updateSubModuleTask2(getTrailingOptions2(arguments, true)), trailingFunctionArgument2(arguments));
@@ -275845,7 +275847,7 @@ init_logger();
 import {
   DuckDBInstance
 } from "@duckdb/node-api";
-import * as path4 from "path";
+import * as path5 from "path";
 
 class DuckDBConnection2 {
   instance = null;
@@ -275853,7 +275855,7 @@ class DuckDBConnection2 {
   dbPath;
   mutex = new Mutex;
   constructor(dbPath) {
-    this.dbPath = dbPath || path4.join(process.cwd(), "publisher.db");
+    this.dbPath = dbPath || path5.join(process.cwd(), "publisher.db");
   }
   async initialize() {
     try {
@@ -276136,6 +276138,94 @@ class EnvironmentRepository {
   }
 }
 
+// src/storage/duckdb/IncrementalLedgerRepository.ts
+class IncrementalLedgerRepository {
+  db;
+  constructor(db) {
+    this.db = db;
+  }
+  async get(environmentId, packageName, sourceEntityId) {
+    const row = await this.db.get(`SELECT * FROM incremental_ledger
+           WHERE environment_id = ? AND package_name = ? AND source_entity_id = ?`, [environmentId, packageName, sourceEntityId]);
+    return row ? mapRow(row) : null;
+  }
+  async upsert(entry) {
+    const now = new Date().toISOString();
+    const rows = await this.db.all(`INSERT INTO incremental_ledger (
+             environment_id, package_name, source_entity_id,
+             covered_through_value, covered_through_type,
+             watermark_dimension, merge_key_dimensions, derived_strategy,
+             physical_table_name, connection_name,
+             advanced_by_materialization_id, advanced_at, created_at
+          ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+          ON CONFLICT (environment_id, package_name, source_entity_id) DO UPDATE SET
+             covered_through_value = EXCLUDED.covered_through_value,
+             covered_through_type = EXCLUDED.covered_through_type,
+             watermark_dimension = EXCLUDED.watermark_dimension,
+             merge_key_dimensions = EXCLUDED.merge_key_dimensions,
+             derived_strategy = EXCLUDED.derived_strategy,
+             physical_table_name = EXCLUDED.physical_table_name,
+             connection_name = EXCLUDED.connection_name,
+             advanced_by_materialization_id = EXCLUDED.advanced_by_materialization_id,
+             advanced_at = EXCLUDED.advanced_at
+          RETURNING *`, [
+      entry.environmentId,
+      entry.packageName,
+      entry.sourceEntityId,
+      entry.coveredThroughValue,
+      entry.coveredThroughType,
+      entry.watermarkDimension,
+      JSON.stringify(entry.mergeKeyDimensions),
+      entry.derivedStrategy,
+      entry.physicalTableName,
+      entry.connectionName,
+      entry.advancedByMaterializationId,
+      now,
+      now
+    ]);
+    return mapRow(rows[0]);
+  }
+  async deleteEntry(environmentId, packageName, sourceEntityId) {
+    await this.db.run(`DELETE FROM incremental_ledger
+           WHERE environment_id = ? AND package_name = ? AND source_entity_id = ?`, [environmentId, packageName, sourceEntityId]);
+  }
+  async deleteByEnvironmentId(environmentId) {
+    await this.db.run("DELETE FROM incremental_ledger WHERE environment_id = ?", [environmentId]);
+  }
+  async deleteByPackage(environmentId, packageName) {
+    await this.db.run("DELETE FROM incremental_ledger WHERE environment_id = ? AND package_name = ?", [environmentId, packageName]);
+  }
+}
+function mapRow(row) {
+  return {
+    environmentId: row.environment_id,
+    packageName: row.package_name,
+    sourceEntityId: row.source_entity_id,
+    coveredThroughValue: row.covered_through_value,
+    coveredThroughType: row.covered_through_type,
+    watermarkDimension: row.watermark_dimension,
+    mergeKeyDimensions: parseNameList(row.merge_key_dimensions),
+    derivedStrategy: row.derived_strategy,
+    physicalTableName: row.physical_table_name,
+    connectionName: row.connection_name,
+    advancedByMaterializationId: row.advanced_by_materialization_id != null ? row.advanced_by_materialization_id : null,
+    advancedAt: new Date(row.advanced_at),
+    createdAt: new Date(row.created_at)
+  };
+}
+function parseNameList(value) {
+  if (value == null)
+    return [];
+  if (Array.isArray(value))
+    return value.map(String);
+  try {
+    const parsed = JSON.parse(String(value));
+    return Array.isArray(parsed) ? parsed.map(String) : [];
+  } catch {
+    return [];
+  }
+}
+
 // src/storage/duckdb/StorageDestinationRepository.ts
 class StorageDestinationRepository {
   db;
@@ -276486,6 +276576,7 @@ class DuckDBRepository {
   connectionRepo;
   destinationRepo;
   materializationRepo;
+  incrementalLedgerRepo;
   constructor(db) {
     this.db = db;
     this.environmentRepo = new EnvironmentRepository(db);
@@ -276493,6 +276584,7 @@ class DuckDBRepository {
     this.connectionRepo = new ConnectionRepository(db);
     this.destinationRepo = new StorageDestinationRepository(db);
     this.materializationRepo = new MaterializationRepository(db);
+    this.incrementalLedgerRepo = new IncrementalLedgerRepository(db);
   }
   async listEnvironments() {
     return this.environmentRepo.listEnvironments();
@@ -276510,6 +276602,7 @@ class DuckDBRepository {
     return this.environmentRepo.updateEnvironment(id, updates);
   }
   async deleteEnvironment(id) {
+    await this.incrementalLedgerRepo.deleteByEnvironmentId(id);
     await this.materializationRepo.deleteByEnvironmentId(id);
     await this.connectionRepo.deleteConnectionsByEnvironmentId(id);
     await this.destinationRepo.deleteByEnvironmentId(id);
@@ -276534,6 +276627,7 @@ class DuckDBRepository {
   async deletePackage(id) {
     const pkg = await this.packageRepo.getPackageById(id);
     if (pkg) {
+      await this.incrementalLedgerRepo.deleteByPackage(pkg.environmentId, pkg.name);
       await this.materializationRepo.deleteByPackage(pkg.environmentId, pkg.name);
     }
     await this.packageRepo.deletePackage(id);
@@ -276601,6 +276695,15 @@ class DuckDBRepository {
   async deleteMaterialization(id) {
     return this.materializationRepo.deleteById(id);
   }
+  async getIncrementalLedgerEntry(environmentId, packageName, sourceEntityId) {
+    return this.incrementalLedgerRepo.get(environmentId, packageName, sourceEntityId);
+  }
+  async upsertIncrementalLedgerEntry(entry) {
+    return this.incrementalLedgerRepo.upsert(entry);
+  }
+  async deleteIncrementalLedgerEntry(environmentId, packageName, sourceEntityId) {
+    return this.incrementalLedgerRepo.deleteEntry(environmentId, packageName, sourceEntityId);
+  }
 }
 
 // src/storage/duckdb/schema.ts
@@ -276682,6 +276785,24 @@ async function initializeSchema(db, force = false) {
       FOREIGN KEY (environment_id) REFERENCES environments(id)
     )
   `);
+  await db.run(`
+    CREATE TABLE IF NOT EXISTS incremental_ledger (
+      environment_id VARCHAR NOT NULL,
+      package_name VARCHAR NOT NULL,
+      source_entity_id VARCHAR NOT NULL,
+      covered_through_value VARCHAR NOT NULL,
+      covered_through_type VARCHAR NOT NULL,
+      watermark_dimension VARCHAR NOT NULL,
+      merge_key_dimensions JSON NOT NULL,
+      derived_strategy VARCHAR NOT NULL,
+      physical_table_name VARCHAR NOT NULL,
+      connection_name VARCHAR NOT NULL,
+      advanced_by_materialization_id VARCHAR,
+      advanced_at TIMESTAMP NOT NULL,
+      created_at TIMESTAMP NOT NULL,
+      PRIMARY KEY (environment_id, package_name, source_entity_id)
+    )
+  `);
   await db.run(`
     CREATE TABLE IF NOT EXISTS themes (
       id VARCHAR PRIMARY KEY,
@@ -276696,6 +276817,7 @@ async function initializeSchema(db, force = false) {
   await db.run("CREATE INDEX IF NOT EXISTS idx_storage_destinations_environment_id ON storage_destinations(environment_id)");
   await db.run("CREATE INDEX IF NOT EXISTS idx_materializations_environment_package ON materializations(environment_id, package_name)");
   await db.run("CREATE UNIQUE INDEX IF NOT EXISTS idx_materializations_active_key ON materializations(active_key)");
+  await db.run("CREATE INDEX IF NOT EXISTS idx_incremental_ledger_environment_package ON incremental_ledger(environment_id, package_name)");
 }
 async function createEntityEmbeddingsTable(db) {
   await db.run(`
@@ -276739,6 +276861,7 @@ async function dropLegacyProjectSchema(db) {
 async function dropAllTables(db) {
   const tables = [
     "build_manifests",
+    "incremental_ledger",
     "materializations",
     "packages",
     "connections",
@@ -276824,7 +276947,7 @@ init_constants();
 init_errors();
 import crypto4 from "crypto";
 import * as fs8 from "fs";
-import * as path8 from "path";
+import * as path9 from "path";
 import { pathToFileURL as pathToFileURL2 } from "url";
 
 // src/service/authorize.ts
@@ -277057,6 +277180,7 @@ function lazyHistogram(name, description, unit) {
 var runCounter = lazyCounter2("publisher_materialization_runs_total", "Materialization builds completed. Labels: mode ('auto'|'orchestrated'), outcome ('success'|'failed'|'cancelled').");
 var runDuration = lazyHistogram("publisher_materialization_run_duration_ms", "Wall-clock duration of a materialization build. Label: mode ('auto'|'orchestrated').", "ms");
 var sourcesCounter = lazyCounter2("publisher_materialization_sources_total", "Persist sources processed by a materialization run. Label: outcome ('built'|'reused').");
+var incrementalStepCounter = lazyCounter2("publisher_materialization_incremental_step_total", 'Refreshes of a source declared refresh="incremental". Labels: step ' + "('delta'|'seed'|'skip'), and for seed/skip a bounded reason code " + "(IncrementalStepReasonCode). A 'seed' is a full rebuild the delta path " + "declined, so a rising seed rate means the feature is not engaging — and " + "the reason label says why without a log dive.");
 var buildPlanComputeDuration = lazyHistogram("publisher_materialization_build_plan_compute_duration_ms", "Wall-clock duration of compiling a package's build plan (Package.buildPlan).", "ms");
 var autoLoadCounter = lazyCounter2("publisher_materialization_auto_load_total", "Auto-run manifest auto-load attempts. Label: outcome ('success'|'failure').");
 var connectionDigestSkipCounter = lazyCounter2("publisher_materialization_connection_digest_skipped_total", "Connection digests skipped during build-plan compile because the connection did not resolve.");
@@ -277083,6 +277207,9 @@ function recordSourcesOutcome(outcome, count) {
     return;
   sourcesCounter().add(count, { outcome });
 }
+function recordIncrementalStep(step, reason) {
+  incrementalStepCounter().add(1, reason ? { step, reason } : { step });
+}
 function recordBuildPlanComputeDuration(durationMs) {
   buildPlanComputeDuration().record(durationMs);
 }
@@ -277125,19 +277252,19 @@ function recordChainedStorageBuild(outcome) {
 
 // src/utils.ts
 import * as fs4 from "fs";
-import * as path5 from "path";
+import * as path6 from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 var URL_READER = {
   readURL: (url2) => {
-    let path6 = url2.toString();
+    let path7 = url2.toString();
     if (url2.protocol == "file:") {
-      path6 = fileURLToPath3(url2);
+      path7 = fileURLToPath3(url2);
     }
-    return fs4.promises.readFile(path6, "utf8");
+    return fs4.promises.readFile(path7, "utf8");
   }
 };
 function ignoreDotfiles(file) {
-  return path5.basename(file).startsWith(".");
+  return path6.basename(file).startsWith(".");
 }
 function errMessage(err) {
   return err instanceof Error ? err.message : String(err);
@@ -277219,7 +277346,7 @@ function splitManifestEntries(entries, source) {
 
 // src/service/package.ts
 import * as fs7 from "fs/promises";
-import * as path7 from "path";
+import * as path8 from "path";
 import"@malloydata/db-duckdb/native";
 import { DuckDBConnection as DuckDBConnection3 } from "@malloydata/db-duckdb";
 import {
@@ -277610,6 +277737,162 @@ init_constants();
 init_logger();
 import { Annotations as Annotations2 } from "@malloydata/malloy";
 
+// src/service/incremental_declaration.ts
+var REFRESH_MODES = ["full", "incremental"];
+var RECOGNIZED_PERSIST_KEYS = new Set([
+  "persist",
+  "name",
+  "storage",
+  "realization",
+  "refresh",
+  "watermark",
+  "merge_key",
+  "freshness",
+  "queryMetadata",
+  "sharing",
+  "schedule"
+]);
+var ORDERABLE_TYPES = new Set([
+  "number",
+  "string",
+  "date",
+  "timestamp"
+]);
+function safeTag(source) {
+  try {
+    return source.annotations.parseAsTag("@").tag;
+  } catch {
+    return;
+  }
+}
+function queryDefinitionFieldKinds(source) {
+  const aggregates = new Set;
+  const analytics = [];
+  try {
+    const def = source._sourceDef;
+    const pipeline = def?.query?.pipeline ?? [];
+    pipeline.forEach((rawSegment, index) => {
+      const segment = rawSegment;
+      const isFinalSegment = index === pipeline.length - 1;
+      for (const field of segment?.queryFields ?? []) {
+        const expressionType = String(field?.expressionType ?? "");
+        const name = field?.type === "fieldref" ? field.path?.[field.path.length - 1] : field?.name;
+        if (typeof name !== "string" || name.length === 0)
+          continue;
+        if (expressionType.includes("analytic")) {
+          analytics.push(name);
+        } else if (expressionType === "aggregate" && isFinalSegment) {
+          aggregates.add(name);
+        }
+      }
+    });
+  } catch {}
+  return { aggregates, analytics };
+}
+function outputColumnTypes(source) {
+  const columns = new Map;
+  for (const column of deriveColumns(source)) {
+    if (column.name && column.type)
+      columns.set(column.name, column.type);
+  }
+  return columns;
+}
+function resolveName(name, columns, aggregates) {
+  const malloyType = columns.get(name);
+  if (malloyType === undefined)
+    return { name, kind: "unresolved" };
+  return {
+    name,
+    kind: aggregates.has(name) ? "aggregate" : "dimension",
+    malloyType
+  };
+}
+function readKey(tag, key) {
+  if (!tag || !tag.has(key))
+    return { declared: false };
+  if (tag.array(key) !== undefined) {
+    return { declared: true, malformed: { key, problem: "array" } };
+  }
+  const text = tag.text(key);
+  if (text === undefined) {
+    return { declared: true, malformed: { key, problem: "empty" } };
+  }
+  if (text.trim().length === 0) {
+    return { declared: true, malformed: { key, problem: "empty" } };
+  }
+  return { declared: true, text: text.trim() };
+}
+function resolveIncrementalDeclaration(source, annotationFields) {
+  const tag = safeTag(source);
+  const columns = outputColumnTypes(source);
+  const { aggregates, analytics } = queryDefinitionFieldKinds(source);
+  const malformed = [];
+  const rawRefresh = readKey(tag, "refresh");
+  if (rawRefresh.malformed)
+    malformed.push(rawRefresh.malformed);
+  const refresh = annotationFields.refresh ?? rawRefresh.text;
+  const incremental = refresh === "incremental";
+  const invalidRefresh = refresh !== undefined && !REFRESH_MODES.includes(refresh) ? refresh : undefined;
+  const rawWatermark = readKey(tag, "watermark");
+  if (rawWatermark.malformed)
+    malformed.push(rawWatermark.malformed);
+  const watermark = rawWatermark.text === undefined ? undefined : resolveName(rawWatermark.text, columns, aggregates);
+  const watermarkOrderable = watermark !== undefined && watermark.kind !== "unresolved" && ORDERABLE_TYPES.has(watermark.malloyType);
+  const rawMergeKey = readKey(tag, "merge_key");
+  if (rawMergeKey.malformed)
+    malformed.push(rawMergeKey.malformed);
+  const mergeKeys = [];
+  if (rawMergeKey.text !== undefined) {
+    const seen = new Set;
+    for (const piece of rawMergeKey.text.split(",")) {
+      const name = piece.trim();
+      if (name.length === 0) {
+        if (!malformed.some((m) => m.key === "merge_key" && m.problem === "empty-entry")) {
+          malformed.push({ key: "merge_key", problem: "empty-entry" });
+        }
+        continue;
+      }
+      if (seen.has(name)) {
+        malformed.push({
+          key: "merge_key",
+          problem: "duplicate",
+          detail: name
+        });
+        continue;
+      }
+      seen.add(name);
+      mergeKeys.push(resolveName(name, columns, aggregates));
+    }
+  }
+  const watermarkInMergeKeys = watermark !== undefined && mergeKeys.some((k) => k.name === watermark.name);
+  const strategy = incremental && watermark !== undefined && watermark.kind === "dimension" ? mergeKeys.length > 0 ? "merge" : "range_replace" : undefined;
+  const unknownKeys = [];
+  if (tag) {
+    try {
+      for (const [key] of tag.entries()) {
+        if (!RECOGNIZED_PERSIST_KEYS.has(key))
+          unknownKeys.push(key);
+      }
+    } catch {}
+  }
+  return {
+    refresh,
+    incremental,
+    invalidRefresh,
+    declaredWatermark: rawWatermark.declared,
+    declaredMergeKey: rawMergeKey.declared,
+    watermark,
+    watermarkOrderable,
+    mergeKeys,
+    watermarkInMergeKeys,
+    strategy,
+    malformed,
+    unknownKeys,
+    calculateFields: analytics,
+    outputColumns: [...columns.keys()]
+  };
+}
+
 // src/service/materialization_eligibility.ts
 init_errors();
 function assertMaterializationEligible(persistSource) {
@@ -277769,7 +278052,7 @@ import {
 import * as fs6 from "fs/promises";
 import { readFileSync } from "fs";
 import { createRequire as createRequire2 } from "module";
-import * as path6 from "path";
+import * as path7 from "path";
 import { fileURLToPath as fileURLToPath5 } from "url";
 init_constants();
 
@@ -279462,7 +279745,7 @@ run: ${sourceName ? `${quoteMalloyIdentifier(sourceName)} -> ` : ""}${quoteMallo
     };
   }
   static async getModelRuntime(packagePath, modelPath, malloyConfig, options) {
-    const fullModelPath = path6.join(packagePath, modelPath);
+    const fullModelPath = path7.join(packagePath, modelPath);
     try {
       if (!(await fs6.stat(fullModelPath)).isFile()) {
         throw new ModelNotFoundError(`${modelPath} is not a file.`);
@@ -279628,7 +279911,7 @@ run: ${sourceName ? `${quoteMalloyIdentifier(sourceName)} -> ` : ""}${quoteMallo
     return this.modelType;
   }
   async getFileText(packagePath) {
-    const fullPath = path6.join(packagePath, this.modelPath);
+    const fullPath = path7.join(packagePath, this.modelPath);
     try {
       return await fs6.readFile(fullPath, "utf8");
     } catch {
@@ -279989,13 +280272,29 @@ function deriveBuildPlan(graphs, sources, connectionDigests, sourceNames, source
 async function computePackageBuildPlan(pkg, signal) {
   const compiled = await compilePackageBuildPlan(pkg, signal);
   const droppedPersistSources = compiled.droppedPersistSources ?? [];
+  const incrementalDeclarations = collectIncrementalDeclarations(compiled.sources);
   const plan = compiled.graphs.length === 0 ? null : deriveBuildPlan(compiled.graphs, compiled.sources, compiled.connectionDigests, undefined, compiled.sourceModelPaths, pkg.getMaterializationConfig?.() ?? null);
   return {
     plan,
     droppedPersistSources,
-    sourceEligibility: collectSourceEligibility(compiled.sources)
+    sourceEligibility: collectSourceEligibility(compiled.sources),
+    incrementalDeclarations
   };
 }
+function collectIncrementalDeclarations(sources) {
+  const declarations = {};
+  for (const [sourceID, source] of Object.entries(sources)) {
+    try {
+      declarations[sourceID] = resolveIncrementalDeclaration(source, deriveAnnotationFields(source));
+    } catch (err) {
+      logger.warn("Failed to resolve a source's incremental declaration", {
+        sourceID,
+        error: errMessage(err)
+      });
+    }
+  }
+  return declarations;
+}
 function collectSourceEligibility(sources) {
   const eligible = [];
   const refused = {};
@@ -280010,6 +280309,606 @@ function collectSourceEligibility(sources) {
   return { eligible, refused };
 }
 
+// src/service/incremental_apply.ts
+init_logger();
+import { decodeDottedTablePath } from "@malloydata/malloy";
+var INCREMENTAL_DIALECT_ALLOWLIST = new Set([
+  "postgres",
+  "snowflake",
+  "standardsql"
+]);
+var MERGE_CAPABLE_DIALECTS = new Set([
+  "postgres",
+  "snowflake",
+  "standardsql"
+]);
+var DIALECT_DISPLAY_NAMES = {
+  standardsql: "standardsql (BigQuery)"
+};
+function describeDialects(dialects) {
+  return [...dialects].sort().map((d) => DIALECT_DISPLAY_NAMES[d] ?? d).join(", ");
+}
+var RENDERABLE_TYPES = new Set(["date", "timestamp", "number", "string"]);
+function isRenderableWatermarkType(malloyType) {
+  return RENDERABLE_TYPES.has(malloyType);
+}
+function escapeSqlString(value, dialect) {
+  const quoted = value.replace(/'/g, "''");
+  return dialect === "snowflake" || dialect === "standardsql" ? quoted.replace(/\\/g, "\\\\") : quoted;
+}
+function secondsPrecision(value) {
+  const match = value.trim().match(/^(\d{4}-\d{2}-\d{2})[T ](\d{2}:\d{2}:\d{2})/);
+  if (!match) {
+    throw new Error(`not an ISO-8601 timestamp: ${JSON.stringify(value)} (expected YYYY-MM-DDTHH:MM:SS)`);
+  }
+  return `${match[1]} ${match[2]}`;
+}
+function datePrecision(value) {
+  const match = value.trim().match(/^(\d{4}-\d{2}-\d{2})/);
+  if (!match) {
+    throw new Error(`not an ISO-8601 date: ${JSON.stringify(value)} (expected YYYY-MM-DD)`);
+  }
+  return match[1];
+}
+function renderSqlBound(bound, dialect) {
+  switch (bound.malloyType) {
+    case "date":
+      return `DATE '${datePrecision(bound.value)}'`;
+    case "timestamp":
+      return `TIMESTAMP '${secondsPrecision(bound.value)}'`;
+    case "number":
+      return renderNumber(bound.value);
+    case "string":
+      return `'${escapeSqlString(bound.value, dialect)}'`;
+    default:
+      throw new Error(`watermark type '${bound.malloyType}' has no literal rendering`);
+  }
+}
+function renderNumber(value) {
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed)) {
+    throw new Error(`not a finite number: ${JSON.stringify(value)}`);
+  }
+  return String(parsed);
+}
+function canonicalBoundValue(malloyType, raw) {
+  if (raw === null || raw === undefined) {
+    throw new Error("watermark value is null");
+  }
+  if (raw instanceof Date) {
+    const iso = raw.toISOString();
+    return {
+      malloyType,
+      value: malloyType === "date" ? iso.slice(0, 10) : iso.slice(0, 19)
+    };
+  }
+  const text = String(typeof raw === "object" && "value" in raw ? raw.value : raw);
+  switch (malloyType) {
+    case "date":
+      return { malloyType, value: datePrecision(text) };
+    case "timestamp":
+      return { malloyType, value: secondsPrecision(text) };
+    case "number":
+      return { malloyType, value: renderNumber(text) };
+    default:
+      return { malloyType, value: text };
+  }
+}
+function snapshotBound(malloyType, now) {
+  return canonicalBoundValue(malloyType, now);
+}
+function deltaSelect(params) {
+  const watermark = quoteIdentifier(params.watermarkName, params.dialect);
+  return `SELECT * FROM (${params.sourceSQL}) AS __d ` + `WHERE ${watermark} >= ${renderSqlBound(params.start, params.dialect)} ` + `AND ${watermark} < ${renderSqlBound(params.end, params.dialect)}`;
+}
+var TABLE_PATH_OPTIONS = {
+  postgres: {
+    quoteChar: '"',
+    escapeStyle: "doubled",
+    bareIdentRegex: /^[A-Za-z_][A-Za-z0-9_$]*/,
+    foldCase: "lower"
+  },
+  snowflake: {
+    quoteChar: '"',
+    escapeStyle: "doubled",
+    bareIdentRegex: /^[A-Za-z_][A-Za-z0-9_$]*/,
+    foldCase: "upper"
+  },
+  standardsql: {
+    quoteChar: "`",
+    escapeStyle: "doubled",
+    bareIdentRegex: /^[A-Za-z_][A-Za-z0-9_-]*/
+  }
+};
+function decodeTablePathSegments(dialect, tablePath) {
+  const opts = TABLE_PATH_OPTIONS[dialect];
+  if (!opts)
+    return;
+  const decoded = decodeDottedTablePath(tablePath, {
+    quoteChar: opts.quoteChar,
+    escapeStyle: opts.escapeStyle,
+    bareIdentRegex: opts.bareIdentRegex,
+    dialectName: dialect
+  });
+  if (!decoded.ok)
+    return;
+  return decoded.segments.map((s) => {
+    if (s.quoted || !opts.foldCase)
+      return s.value;
+    return opts.foldCase === "lower" ? s.value.toLowerCase() : s.value.toUpperCase();
+  });
+}
+function probeSelect(dialect, innerSelect) {
+  return dialect === "postgres" ? `SELECT row_to_json(__p) AS "row" FROM (${innerSelect}) AS __p` : innerSelect;
+}
+function probeRows(rows) {
+  return rows.filter((r) => typeof r === "object" && r !== null);
+}
+function probeAlias(name, dialect) {
+  return quoteIdentifier(name, dialect);
+}
+async function probeTargetColumns(runner, dialect, physicalTableName) {
+  const segments = decodeTablePathSegments(dialect, physicalTableName);
+  if (!segments || segments.length === 0) {
+    return {
+      columns: [],
+      error: `physical table name ${JSON.stringify(physicalTableName)} is not a decodable ${dialect} table path`
+    };
+  }
+  let sql;
+  if (dialect === "postgres" || dialect === "snowflake") {
+    const table = segments[segments.length - 1];
+    const schema = segments.length >= 2 ? `'${escapeSqlString(segments[segments.length - 2], dialect)}'` : "current_schema()";
+    const infoSchema = dialect === "snowflake" && segments.length >= 3 ? `${quoteIdentifier(segments[segments.length - 3], dialect)}.information_schema.columns` : "information_schema.columns";
+    sql = probeSelect(dialect, `SELECT column_name AS ${probeAlias("column_name", dialect)}
+           FROM ${infoSchema}
+           WHERE table_schema = ${schema}
+             AND table_name = '${escapeSqlString(table, dialect)}'
+           ORDER BY ordinal_position`);
+  } else {
+    if (segments.length < 2) {
+      return {
+        columns: [],
+        error: `physical table name ${JSON.stringify(physicalTableName)} is not ` + `dataset-qualified, so its schema cannot be read from ` + `INFORMATION_SCHEMA`
+      };
+    }
+    const table = segments[segments.length - 1];
+    const container = segments.slice(0, -1).map((s) => quoteIdentifier(s, dialect)).join(".");
+    sql = `SELECT column_name AS ${probeAlias("column_name", dialect)}
+              FROM ${container}.INFORMATION_SCHEMA.COLUMNS
+              WHERE table_name = '${escapeSqlString(table, dialect)}'
+              ORDER BY ordinal_position`;
+  }
+  try {
+    const result = await runner(sql);
+    const columns = probeRows(result.rows).map((r) => r["column_name"]).filter((n) => typeof n === "string" && n.length > 0);
+    return { columns };
+  } catch (err) {
+    return { columns: [], error: errMessage(err) };
+  }
+}
+async function probeTargetNonEmpty(runner, dialect, quotedTablePath) {
+  const sql = probeSelect(dialect, `SELECT 1 AS present FROM ${quotedTablePath} LIMIT 1`);
+  try {
+    const result = await runner(sql);
+    return { nonEmpty: probeRows(result.rows).length > 0 };
+  } catch (err) {
+    return { nonEmpty: false, error: errMessage(err) };
+  }
+}
+async function probeMaxWatermark(runner, dialect, innerSelect, watermarkName, malloyType) {
+  const column = quoteIdentifier(watermarkName, dialect);
+  const sql = probeSelect(dialect, `SELECT MAX(${column}) AS ${probeAlias("watermark_max", dialect)} ` + `FROM (${innerSelect}) AS __w`);
+  try {
+    const result = await runner(sql);
+    const raw = probeRows(result.rows)[0]?.["watermark_max"];
+    if (raw === null || raw === undefined)
+      return {};
+    return { bound: canonicalBoundValue(malloyType, raw) };
+  } catch (err) {
+    return { error: errMessage(err) };
+  }
+}
+async function probePostgresVersion(runner) {
+  try {
+    const result = await runner(probeSelect("postgres", `SELECT current_setting('server_version_num') AS version_num`));
+    const raw = probeRows(result.rows)[0]?.["version_num"];
+    const parsed = Number(raw);
+    return Number.isFinite(parsed) ? parsed : undefined;
+  } catch {
+    return;
+  }
+}
+var POSTGRES_MERGE_MIN_VERSION_NUM = 150000;
+function compareBounds(a, b) {
+  if (a.malloyType !== b.malloyType) {
+    throw new Error(`cannot compare a ${a.malloyType} bound to a ${b.malloyType} bound`);
+  }
+  if (a.malloyType === "number")
+    return Number(a.value) - Number(b.value);
+  return a.value < b.value ? -1 : a.value > b.value ? 1 : 0;
+}
+function shapeMismatch(deltaColumns, targetColumns) {
+  const target = new Set(targetColumns);
+  const delta = new Set(deltaColumns);
+  const missing = deltaColumns.filter((c) => !target.has(c));
+  const extra = targetColumns.filter((c) => !delta.has(c));
+  if (missing.length === 0 && extra.length === 0)
+    return;
+  const parts = [];
+  if (missing.length > 0) {
+    parts.push(`absent from the table: ${missing.map((c) => `"${c}"`).join(", ")}`);
+  }
+  if (extra.length > 0) {
+    parts.push(`present only in the table: ${extra.map((c) => `"${c}"`).join(", ")}`);
+  }
+  return parts.join("; ");
+}
+function deltaStatements(params) {
+  const {
+    dialect,
+    quotedTablePath,
+    deltaSQL,
+    columns,
+    mergeKeys,
+    watermarkName
+  } = params;
+  const q = (name) => quoteIdentifier(name, dialect);
+  const columnList = columns.map(q).join(", ");
+  if (mergeKeys.length > 0) {
+    const keys = new Set(mergeKeys);
+    const on = mergeKeys.map((k) => `(__t.${q(k)} = __s.${q(k)} OR (__t.${q(k)} IS NULL AND __s.${q(k)} IS NULL))`).join(" AND ");
+    const updates = columns.filter((c) => !keys.has(c)).map((c) => `${q(c)} = __s.${q(c)}`);
+    const clauses = [
+      `MERGE INTO ${quotedTablePath} AS __t`,
+      `USING (${deltaSQL}) AS __s`,
+      `ON ${on}`
+    ];
+    if (updates.length > 0) {
+      clauses.push(`WHEN MATCHED THEN UPDATE SET ${updates.join(", ")}`);
+    }
+    clauses.push(`WHEN NOT MATCHED THEN INSERT (${columnList}) ` + `VALUES (${columns.map((c) => `__s.${q(c)}`).join(", ")})`);
+    return [clauses.join(`
+`)];
+  }
+  const watermark = q(watermarkName);
+  const range = `${watermark} >= ${renderSqlBound(params.start, dialect)} AND ` + `${watermark} < ${renderSqlBound(params.end, dialect)}`;
+  const body = [
+    `DELETE FROM ${quotedTablePath} WHERE ${range}`,
+    `INSERT INTO ${quotedTablePath} (${columnList}) ` + `SELECT ${columnList} FROM (${deltaSQL}) AS __s`
+  ];
+  if (dialect === "snowflake")
+    return [snowflakeScriptingBlock(body)];
+  const transaction = transactionKeywords(dialect);
+  return [transaction.begin, ...body, transaction.commit];
+}
+function snowflakeScriptingBlock(statements) {
+  const body = statements.map((s) => `  ${s};`).join(`
+`);
+  const block = `BEGIN
+  BEGIN TRANSACTION;
+${body}
+  COMMIT;
+EXCEPTION
+  WHEN OTHER THEN
+    ROLLBACK;
+    RAISE;
+END`;
+  if (block.includes("$$")) {
+    throw new Error("the delta SQL contains '$$', which cannot be carried inside a " + "Snowflake Scripting block");
+  }
+  return `EXECUTE IMMEDIATE $$
+${block}
+$$`;
+}
+function transactionKeywords(dialect) {
+  return dialect === "standardsql" ? {
+    begin: "BEGIN TRANSACTION",
+    commit: "COMMIT TRANSACTION",
+    rollback: "ROLLBACK TRANSACTION"
+  } : { begin: "BEGIN", commit: "COMMIT", rollback: "ROLLBACK" };
+}
+function deltaScript(statements) {
+  return statements.map((s) => `${s};`).join(`
+`);
+}
+async function applyDeltaScript(runner, dialect, statements) {
+  try {
+    await runner(deltaScript(statements));
+  } catch (err) {
+    if (statements.length > 1) {
+      try {
+        await runner(transactionKeywords(dialect).rollback);
+      } catch (rollbackErr) {
+        logger.warn("Could not roll back a failed delta; a pooled connection may " + "stay in an aborted transaction", { dialect, error: errMessage(rollbackErr) });
+      }
+    }
+    throw err;
+  }
+}
+function ledgerLineageMismatch(entry, lineage) {
+  if (entry.physicalTableName !== lineage.physicalTableName) {
+    return {
+      reasonCode: "table_renamed",
+      reason: `the recorded boundary belongs to table ` + `"${entry.physicalTableName}", not "${lineage.physicalTableName}" — ` + `either this table was renamed between runs, or another source ` + `shares this source's content address and advanced the boundary ` + `against its own table`
+    };
+  }
+  const changed = (reason) => ({ reasonCode: "lineage_changed", reason });
+  if (entry.connectionName !== lineage.connectionName) {
+    return changed(`the recorded boundary was advanced on connection ` + `"${entry.connectionName}", not "${lineage.connectionName}"`);
+  }
+  if (entry.watermarkDimension !== lineage.watermarkName) {
+    return changed(`the watermark changed from "${entry.watermarkDimension}" to ` + `"${lineage.watermarkName}", so the recorded value measures a ` + `different column`);
+  }
+  if (entry.coveredThroughType !== lineage.watermarkType) {
+    return changed(`the watermark's type changed from "${entry.coveredThroughType}" to ` + `"${lineage.watermarkType}"`);
+  }
+  if (entry.derivedStrategy !== lineage.strategy) {
+    return changed(`the strategy changed from ${entry.derivedStrategy} to ` + `${lineage.strategy}`);
+  }
+  const recorded = entry.mergeKeyDimensions;
+  if (recorded.length !== lineage.mergeKeys.length || recorded.some((k, i) => k !== lineage.mergeKeys[i])) {
+    return changed(`merge_key= changed from [${recorded.join(", ")}] to ` + `[${lineage.mergeKeys.join(", ")}]`);
+  }
+  return;
+}
+async function resolveDeltaEnd(runner, dialect, lineage, sourceSQL, now) {
+  const type = lineage.watermarkType;
+  if (type === "date" || type === "timestamp") {
+    return { bound: snapshotBound(type, now) };
+  }
+  return probeMaxWatermark(runner, dialect, sourceSQL, lineage.watermarkName, type);
+}
+async function planIncrementalStep(inputs) {
+  const { runner, dialect, lineage, ledgerEntry } = inputs;
+  if (inputs.forceRefresh) {
+    return {
+      mode: "seed",
+      reasonCode: "forced",
+      reason: "a full refresh was requested"
+    };
+  }
+  if (!ledgerEntry) {
+    return {
+      mode: "seed",
+      reasonCode: "no_boundary",
+      reason: "no covered_through boundary is recorded for this source yet"
+    };
+  }
+  const mismatch = ledgerLineageMismatch(ledgerEntry, lineage);
+  if (mismatch) {
+    return { mode: "seed", ...mismatch };
+  }
+  if (lineage.strategy === "merge" && dialect === "postgres" && (inputs.postgresVersionNum ?? 0) < POSTGRES_MERGE_MIN_VERSION_NUM) {
+    return {
+      mode: "seed",
+      reasonCode: "merge_unsupported",
+      reason: `merge_key= needs MERGE, which this Postgres server ` + `(server_version_num ${inputs.postgresVersionNum ?? "unknown"}) ` + `does not have; MERGE requires Postgres 15`
+    };
+  }
+  const probe = await probeTargetColumns(runner, dialect, lineage.physicalTableName);
+  if (probe.columns.length === 0) {
+    return {
+      mode: "seed",
+      reasonCode: "table_unreadable",
+      reason: `the target table could not be described` + (probe.error ? ` (${probe.error})` : ", so it is treated as absent")
+    };
+  }
+  const rows = await probeTargetNonEmpty(runner, dialect, inputs.quotedTablePath);
+  if (!rows.nonEmpty) {
+    return {
+      mode: "seed",
+      reasonCode: "table_emptied",
+      reason: `the target table is empty while a covered_through boundary of ` + `${ledgerEntry.coveredThroughValue} is recorded, so its rows were ` + `removed outside this ledger` + (rows.error ? ` (${rows.error})` : "")
+    };
+  }
+  const start = {
+    malloyType: ledgerEntry.coveredThroughType,
+    value: ledgerEntry.coveredThroughValue
+  };
+  const end = await resolveDeltaEnd(runner, dialect, lineage, inputs.sourceSQL, inputs.now);
+  if (!end.bound) {
+    return {
+      mode: "skip",
+      reasonCode: end.error ? "frontier_unreadable" : "not_advanced",
+      reason: end.error ? `the watermark frontier could not be read (${end.error})` : "the source has no rows with a non-null watermark",
+      coveredThrough: start
+    };
+  }
+  if (compareBounds(end.bound, start) <= 0) {
+    return {
+      mode: "skip",
+      reasonCode: "not_advanced",
+      reason: `the watermark has not advanced past ${start.value} ` + `(frontier: ${end.bound.value})`,
+      coveredThrough: start
+    };
+  }
+  const shape = shapeMismatch(inputs.columns, probe.columns);
+  if (shape) {
+    return {
+      mode: "seed",
+      reasonCode: "shape_mismatch",
+      reason: `the delta's columns do not match the target table's (${shape}), ` + `so a delta would write a different shape than the table holds`
+    };
+  }
+  const statements = deltaStatements({
+    dialect,
+    quotedTablePath: inputs.quotedTablePath,
+    deltaSQL: deltaSelect({
+      dialect,
+      sourceSQL: inputs.sourceSQL,
+      watermarkName: lineage.watermarkName,
+      start,
+      end: end.bound
+    }),
+    columns: inputs.columns,
+    mergeKeys: lineage.mergeKeys,
+    watermarkName: lineage.watermarkName,
+    start,
+    end: end.bound
+  });
+  return {
+    mode: "delta",
+    start,
+    end: end.bound,
+    coveredThrough: end.bound,
+    statements
+  };
+}
+async function seedCoveredThrough(runner, dialect, lineage, quotedTablePath, now) {
+  const frontier = await probeMaxWatermark(runner, dialect, `SELECT ${quoteIdentifier(lineage.watermarkName, dialect)} FROM ${quotedTablePath}`, lineage.watermarkName, lineage.watermarkType);
+  if (frontier.error || !frontier.bound)
+    return frontier;
+  const type = lineage.watermarkType;
+  return type === "date" || type === "timestamp" ? { bound: snapshotBound(type, now) } : frontier;
+}
+
+// src/service/incremental_policy.ts
+var MODE = `refresh="incremental"`;
+function quoteList(names) {
+  return names.map((n) => `"${n}"`).join(", ");
+}
+function unresolved(names) {
+  return names.filter((n) => n !== undefined && n.kind === "unresolved");
+}
+function aggregateBacked(names) {
+  return names.filter((n) => n !== undefined && n.kind === "aggregate");
+}
+function malformedMessage(sourceName, key, problem, detail) {
+  const where = `#@ persist source "${sourceName}"`;
+  switch (problem) {
+    case "array":
+      return `${where} declares ${key}=[…] as a tag ARRAY. Write ONE quoted ` + `string instead: ${key}="order_date"` + (key === "merge_key" ? `, and separate a compound key with commas inside that one ` + `string — merge_key="order_id, region".` : `.`) + ` An array value is dropped from the annotation's scalar fields, so ` + `the key would otherwise read as undeclared.`;
+    case "empty":
+      return `${where} declares ${key}="" (empty). Name an output dimension of ` + `the source, or remove the key (use -${key} to strip one inherited ` + `from a parent source).`;
+    case "empty-entry":
+      return `${where} declares a merge_key= list with an empty entry (e.g. ` + `merge_key="order_id,,region"). Remove the stray comma — an empty ` + `entry would silently narrow row identity to fewer columns than ` + `intended.`;
+    case "duplicate":
+      return `${where} declares merge_key= with "${detail}" repeated. List each ` + `dimension once.`;
+    default:
+      return `${where} declares an unusable ${key}= value.`;
+  }
+}
+function incrementalPolicyRejections(sources) {
+  const rejections = [];
+  for (const source of sources) {
+    rejections.push(...rejectionsForSource(source));
+  }
+  return rejections;
+}
+function rejectionsForSource(source) {
+  const { sourceName, declaration: d } = source;
+  const where = `#@ persist source "${sourceName}"`;
+  const out = [];
+  if (d.invalidRefresh !== undefined) {
+    out.push(`${where} declares refresh=${JSON.stringify(d.invalidRefresh)}, which ` + `is not a refresh mode. Use refresh="full" (the default: rebuild the ` + `whole table) or refresh="incremental" (advance it by a bounded ` + `delta). The value is case-sensitive.`);
+  }
+  for (const m of d.malformed) {
+    out.push(malformedMessage(sourceName, m.key, m.problem, m.detail));
+  }
+  if (!d.incremental && (d.declaredWatermark || d.declaredMergeKey)) {
+    const keys = [
+      d.declaredWatermark ? "watermark=" : undefined,
+      d.declaredMergeKey ? "merge_key=" : undefined
+    ].filter((k) => k !== undefined);
+    out.push(`${where} declares ${keys.join(" and ")} but is not ${MODE}` + (d.refresh ? ` (it declares refresh=${JSON.stringify(d.refresh)})` : "") + `. These keys describe how an INCREMENTAL refresh advances the ` + `table and are ignored by a full rebuild. Either add ${MODE}, or ` + `remove the key — and if the key is inherited from a parent source, ` + `strip it with a negation (e.g. -watermark), since removing the ` + `parent's key is not an option from the child.`);
+  }
+  if (d.declaredMergeKey && !d.declaredWatermark) {
+    out.push(`${where} declares merge_key= without watermark=. The declaration is a ` + `chain: merge_key= needs watermark=, and watermark= needs ${MODE}. ` + `merge_key= only says how to match a row the delta rewrites; ` + `watermark= is what BOUNDS the delta in the first place, so a merge ` + `key on its own has no range to apply. Declare all three, or none.`);
+  }
+  if (d.incremental && !d.declaredWatermark) {
+    out.push(`${where} declares ${MODE} but no watermark=. An incremental refresh ` + `derives its range from a monotone non-decreasing output dimension, ` + `so name one: watermark="order_date". Without it there is no ` + `boundary to advance and nothing to bound the delta.`);
+  }
+  if (!d.incremental)
+    return out;
+  const dialect = source.dialect ?? "";
+  if (!INCREMENTAL_DIALECT_ALLOWLIST.has(dialect)) {
+    out.push(`${where} declares ${MODE}, which is not supported on dialect ` + `"${dialect || "unknown"}". Incremental refresh applies its delta to ` + `the live serving table, so it is enabled only where the publisher ` + `has proven transactional DML: ` + `${describeDialects(INCREMENTAL_DIALECT_ALLOWLIST)}. Use ` + `refresh="full" here; the supported set widens in a later release.`);
+  } else if (d.declaredMergeKey && !MERGE_CAPABLE_DIALECTS.has(dialect)) {
+    out.push(`${where} declares merge_key=, which needs a MERGE statement that ` + `dialect "${dialect}" does not have. Remove merge_key= to replace ` + `the watermark range instead of merging by row identity.`);
+  }
+  if (source.storageDestination) {
+    out.push(`${where} declares ${MODE} together with ` + `storage="${source.storageDestination}". A stored source is ` + `materialized into the storage destination's own engine, while an ` + `incremental delta is applied on the source warehouse — so the two ` + `cannot be combined yet. Drop one: refresh="full" keeps the storage ` + `destination, removing storage= keeps the incremental refresh in the ` + `source warehouse.`);
+  }
+  const dangling = unresolved([d.watermark, ...d.mergeKeys]);
+  if (dangling.length > 0) {
+    out.push(`${where} declares ${quoteList(dangling.map((n) => n.name))} which ` + `${dangling.length === 1 ? "is not" : "are not"} ` + `${dangling.length === 1 ? "a column" : "columns"} of the source's ` + `materialized output. Available: ${quoteList(d.outputColumns)}. Note ` + `that a derived dimension: on a table-backed source is queryable but ` + `NOT materialized, so it cannot be a watermark or merge key.`);
+  }
+  const aggregates = aggregateBacked([d.watermark, ...d.mergeKeys]);
+  if (aggregates.length > 0) {
+    out.push(`${where} declares ${quoteList(aggregates.map((n) => n.name))} which ` + `${aggregates.length === 1 ? "is" : "are"} produced by aggregate: in ` + `the source's query. An aggregate is a measured VALUE of a row, not ` + `an identity or an arrival order: it changes when new input lands, so ` + `it can neither bound a delta nor match a row. Name a group_by: ` + `dimension instead.`);
+  }
+  if (d.watermark !== undefined && d.watermark.kind !== "unresolved" && !d.watermarkOrderable) {
+    out.push(`${where} declares watermark="${d.watermark.name}", of type ` + `${d.watermark.malloyType}, which has no ordering to build a range ` + `from. A watermark must be a date, timestamp, number or string ` + `dimension that only moves forward.`);
+  }
+  if (d.watermarkInMergeKeys && d.watermark !== undefined) {
+    out.push(`${where} declares merge_key= including the watermark dimension ` + `"${d.watermark.name}". Row identity must be independent of the ` + `watermark: a row restated with a LATER watermark value would not ` + `match its predecessor, so it would be inserted alongside the old ` + `row rather than replacing it — the failure merge_key= exists to ` + `prevent. List only the identity dimensions.`);
+  }
+  if (d.calculateFields.length > 0) {
+    out.push(`${where} declares ${MODE} but computes ` + `${quoteList([...new Set(d.calculateFields)])} with calculate:. A ` + `window function is not supported on an incremental source yet: a ` + `delta recomputes only rows inside its range, so a frame that reaches ` + `outside that range assigns already-materialized rows values that ` + `later data changes, below the range start where no delta ever ` + `rewrites them. Frames strictly BACKWARD along the watermark ordering ` + `are stable and will become legal; every other frame will not. Use ` + `refresh="full", or move the window computation into the query that ` + `reads this source. (Plain non-additive aggregates like ` + `count_distinct are fine — a delta recomputes whole output rows from ` + `full input and never merges partial aggregates.)`);
+  }
+  return out;
+}
+function recordedLineage(d) {
+  const watermark = d.watermark;
+  return [
+    d.incremental ? "incremental" : "full",
+    watermark?.name ?? "",
+    watermark && watermark.kind !== "unresolved" ? watermark.malloyType : "",
+    d.strategy ?? "",
+    d.mergeKeys.map((k) => k.name).join("+")
+  ].join("|");
+}
+function sharedAddressAdvisories(sources) {
+  const byAddress = new Map;
+  for (const source of sources) {
+    if (!source.sourceEntityId)
+      continue;
+    const group = byAddress.get(source.sourceEntityId);
+    if (group)
+      group.push(source);
+    else
+      byAddress.set(source.sourceEntityId, [source]);
+  }
+  const warnings = [];
+  for (const group of byAddress.values()) {
+    if (group.length < 2)
+      continue;
+    if (!group.some((s) => s.declaration.incremental))
+      continue;
+    const conflicting = new Set(group.map((s) => recordedLineage(s.declaration))).size > 1;
+    for (const source of group) {
+      const others = group.filter((s) => s !== source).map((s) => s.sourceName);
+      warnings.push({
+        model: source.modelPath ?? "",
+        subject: source.sourceName,
+        message: `compiles to the same SQL as ${quoteList(others)} on the same ` + `connection, so they share ONE content address — and therefore ` + `one materialized table and one covered_through boundary. ` + (conflicting ? `Their incremental declarations DISAGREE, so that single ` + `boundary cannot describe both: each refresh finds the ` + `other's lineage recorded and rebuilds in full instead of ` + `advancing, indefinitely. Give them different definitions ` + `or keep only one.` : `Only one is materialized; the other's name= table is never ` + `built. Keep one, unless the duplication is intentional.`)
+      });
+    }
+  }
+  return warnings;
+}
+function incrementalPolicyAdvisories(sources) {
+  const warnings = sharedAddressAdvisories(sources);
+  for (const source of sources) {
+    const { declaration: d } = source;
+    const at = { model: source.modelPath ?? "", subject: source.sourceName };
+    for (const key of d.unknownKeys) {
+      warnings.push({
+        ...at,
+        message: `declares an unrecognized #@ persist key "${key}", which the ` + `publisher passes through untouched. If it is a typo the intended ` + `behavior is silently absent — note that a misspelled merge_key= ` + `leaves an incremental source applying its delta by range replace ` + `instead of by row identity.`
+      });
+    }
+    if (d.incremental && d.watermark !== undefined && !d.declaredMergeKey) {
+      warnings.push({
+        ...at,
+        message: `is ${MODE} with no merge_key=, so each refresh REPLACES the ` + `watermark range it just computed. Two consequences worth ` + `checking: (a) a row that is later restated with an ADVANCED ` + `watermark value appears twice rather than replacing its ` + `predecessor, since the older row sits below the new range — ` + `declare merge_key= with the row's identity dimensions if that ` + `happens; (b) if the destination table is not partitioned or ` + `clustered on "${d.watermark.name}", the range DELETE may re-read ` + `the whole table on every run.`
+      });
+    }
+  }
+  return warnings;
+}
+
 // src/service/materialization_config_validation.ts
 function metadataWarnings(level, metadata, subject) {
   if (!metadata)
@@ -280137,6 +281036,9 @@ function packageLoadFailureStatus(error) {
   if (error instanceof ModelCompilationError || error instanceof MalloyError3) {
     return "compilation_error";
   }
+  if (error instanceof BadRequestError) {
+    return "policy_rejected";
+  }
   if (error instanceof ServiceUnavailableError) {
     return "pool_unavailable";
   }
@@ -280162,6 +281064,7 @@ class Package {
   buildPlan = null;
   droppedPersistSources = [];
   sourceEligibility = undefined;
+  incrementalPolicySources = [];
   renderTagWarnings = [];
   manifestWarnings = [];
   static meter = publisherMeter();
@@ -280315,7 +281218,7 @@ class Package {
           });
         }
         if (sm.modelPath.endsWith(MODEL_FILE_SUFFIX)) {
-          const modelSource = await fs7.readFile(path7.join(packagePath, sm.modelPath), "utf-8");
+          const modelSource = await fs7.readFile(path8.join(packagePath, sm.modelPath), "utf-8");
           assertPersistNamesQuoted(modelSource, sm.modelPath);
         }
         models.set(sm.modelPath, model);
@@ -280341,10 +281244,23 @@ class Package {
     pkg.wireFreshnessResolvers();
     try {
       const buildPlanStart = Date.now();
-      const { plan, droppedPersistSources, sourceEligibility } = await computePackageBuildPlan(pkg);
+      const {
+        plan,
+        droppedPersistSources,
+        sourceEligibility,
+        incrementalDeclarations
+      } = await computePackageBuildPlan(pkg);
       pkg.buildPlan = plan;
       pkg.droppedPersistSources = droppedPersistSources;
       pkg.sourceEligibility = sourceEligibility;
+      pkg.incrementalPolicySources = Object.entries(plan?.sources ?? {}).filter(([sourceID]) => incrementalDeclarations[sourceID]).map(([sourceID, source]) => ({
+        sourceName: source.name,
+        modelPath: source.modelPath,
+        dialect: source.dialect,
+        storageDestination: source.annotationFields?.storage,
+        sourceEntityId: source.sourceEntityId,
+        declaration: incrementalDeclarations[sourceID]
+      }));
       recordBuildPlanComputeDuration(Date.now() - buildPlanStart);
     } catch (err) {
       logger.warn(`Failed to compute build plan for package ${packageName}`, {
@@ -280366,6 +281282,14 @@ class Package {
         detail: invalidPolicy
       });
     }
+    const invalidIncremental = pkg.formatInvalidIncrementalPolicy();
+    if (invalidIncremental) {
+      logger.error(`Package ${packageName} has an invalid incremental refresh policy`, {
+        packageName,
+        detail: invalidIncremental
+      });
+      throw new BadRequestError(invalidIncremental);
+    }
     const collisions = pkg.persistenceCollisionWarnings();
     if (collisions.length > 0) {
       logger.warn(`Package ${packageName} has persist-target collisions`, {
@@ -280404,6 +281328,7 @@ class Package {
       ...this.storageWarnings(),
       ...this.droppedPersistWarnings(),
       ...this.persistenceCollisionWarnings().map((message) => ({ message })),
+      ...incrementalPolicyAdvisories(this.incrementalPolicySources),
       ...materializationConfigWarnings({
         packageMaterialization: this.packageMetadata.materialization,
         sources: this.buildPlan?.sources ? Object.values(this.buildPlan.sources) : [],
@@ -280593,6 +281518,13 @@ class Package {
   }
   formatInvalidPersistencePolicy() {
     return this.persistencePolicyWarnings().join(`
+`);
+  }
+  incrementalPolicyWarnings() {
+    return incrementalPolicyRejections(this.incrementalPolicySources);
+  }
+  formatInvalidIncrementalPolicy() {
+    return this.incrementalPolicyWarnings().join(`
 `);
   }
   persistenceCollisionWarnings() {
@@ -280889,16 +281821,16 @@ class Package {
   static async getDatabasePaths(packagePath) {
     const files = await import_recursive_readdir.default(packagePath, [ignoreDotfiles]);
     return files.map((fullPath) => {
-      return path7.relative(packagePath, fullPath).replace(/\\/g, "/");
+      return path8.relative(packagePath, fullPath).replace(/\\/g, "/");
     }).filter((modelPath) => {
-      if (path7.basename(modelPath).startsWith("~$")) {
+      if (path8.basename(modelPath).startsWith("~$")) {
         return false;
       }
       return modelPath.endsWith(".parquet") || modelPath.endsWith(".csv") || modelPath.endsWith(".xlsx");
     });
   }
   static async getDatabaseInfo(packagePath, databasePath, conn) {
-    const fullPath = path7.join(packagePath, databasePath);
+    const fullPath = path8.join(packagePath, databasePath);
     const runtime = new ConnectionRuntime({
       urlReader: new EmptyURLReader,
       connections: [conn]
@@ -280999,7 +281931,7 @@ class Environment {
   async writeEnvironmentReadme(readme) {
     if (readme === undefined)
       return;
-    const readmePath = path8.join(this.environmentPath, "README.md");
+    const readmePath = path9.join(this.environmentPath, "README.md");
     try {
       await fs8.promises.writeFile(readmePath, readme, "utf-8");
       logger.info(`Updated README.md for environment ${this.environmentName}`);
@@ -281077,8 +282009,8 @@ class Environment {
     }
     return this.withPackageLock(packageName, async () => {
       const modelPath = safeJoinUnderRoot(this.environmentPath, packageName, modelName);
-      const modelDir = path8.dirname(modelPath);
-      const virtualUrl = pathToFileURL2(path8.join(modelDir, "__compile_check.malloy"));
+      const modelDir = path9.dirname(modelPath);
+      const virtualUrl = pathToFileURL2(path9.join(modelDir, "__compile_check.malloy"));
       const virtualUri = virtualUrl.toString();
       let modelContent = "";
       try {
@@ -281314,7 +282246,7 @@ ${source}` : source;
       const dir = safeJoinUnderRoot(environmentPath, dirName);
       if (dir.indexOf("..") !== -1)
         continue;
-      if (path8.basename(dir) !== dirName)
+      if (path9.basename(dir) !== dirName)
         continue;
       try {
         await fs8.promises.rm(dir, { recursive: true, force: true });
@@ -281450,7 +282382,7 @@ ${source}` : source;
   async installPackage(packageName, downloader, validate) {
     assertSafePackageName(packageName);
     const stagingPath = this.allocateStagingPath(packageName);
-    await fs8.promises.mkdir(path8.dirname(stagingPath), { recursive: true });
+    await fs8.promises.mkdir(path9.dirname(stagingPath), { recursive: true });
     logger.debug("install.phase1.download.started", {
       environmentName: this.environmentName,
       packageName,
@@ -281479,7 +282411,7 @@ ${source}` : source;
       const oldExistsOnDisk = await fs8.promises.access(canonicalPath).then(() => true).catch(() => false);
       if (oldExistsOnDisk) {
         retiredPath = this.allocateRetiredPath(packageName);
-        await fs8.promises.mkdir(path8.dirname(retiredPath), {
+        await fs8.promises.mkdir(path9.dirname(retiredPath), {
           recursive: true
         });
         await fs8.promises.rename(canonicalPath, retiredPath);
@@ -281829,7 +282761,7 @@ ${source}` : source;
       const retiredPath = this.allocateRetiredPath(packageName);
       let renamed = false;
       try {
-        await fs8.promises.mkdir(path8.dirname(retiredPath), {
+        await fs8.promises.mkdir(path9.dirname(retiredPath), {
           recursive: true
         });
         await fs8.promises.rename(canonicalPath, retiredPath);
@@ -281928,7 +282860,7 @@ ${source}` : source;
     };
   }
   async deleteDuckDBConnection(connectionName) {
-    const duckdbPath = path8.join(this.environmentPath, `${connectionName}.duckdb`);
+    const duckdbPath = path9.join(this.environmentPath, `${connectionName}.duckdb`);
     try {
       await fs8.promises.rm(duckdbPath, { force: true });
       logger.info(`Removed DuckDB connection file ${connectionName} from environment ${this.environmentName}`);
@@ -282006,9 +282938,9 @@ function resolvePackageLocation(location, anchorDir, homeDir) {
     if (!home) {
       throw new Error(`Cannot expand "~" in location "${location}": home directory is not set`);
     }
-    expanded = path9.join(home, location.slice(2));
+    expanded = path10.join(home, location.slice(2));
   }
-  return path9.isAbsolute(expanded) ? expanded : path9.join(anchorDir, expanded);
+  return path10.isAbsolute(expanded) ? expanded : path10.join(anchorDir, expanded);
 }
 var GIT_CLONE_OPTIONS = {
   "--depth": 1,
@@ -282186,7 +283118,7 @@ class EnvironmentStore {
     const storageConfig = {
       type: "duckdb",
       duckdb: {
-        path: path9.join(serverRootPath, "publisher.db")
+        path: path10.join(serverRootPath, "publisher.db")
       }
     };
     this.storageManager = new StorageManager(storageConfig);
@@ -282601,7 +283533,7 @@ class EnvironmentStore {
     const reInit = process.env.INITIALIZE_STORAGE === "true";
     await fs9.promises.mkdir(this.serverRootPath, { recursive: true });
     if (reInit) {
-      const uploadDocsPath2 = path9.join(this.serverRootPath, PUBLISHER_DATA_DIR);
+      const uploadDocsPath2 = path10.join(this.serverRootPath, PUBLISHER_DATA_DIR);
       logger.info(`Reinitialization mode: Cleaning up upload documents path ${uploadDocsPath2}`);
       try {
         await fs9.promises.rm(uploadDocsPath2, {
@@ -282618,7 +283550,7 @@ class EnvironmentStore {
     } else {
       logger.info(`Using existing publisher path`);
     }
-    const uploadDocsPath = path9.join(this.serverRootPath, PUBLISHER_DATA_DIR);
+    const uploadDocsPath = path10.join(this.serverRootPath, PUBLISHER_DATA_DIR);
     await fs9.promises.mkdir(uploadDocsPath, { recursive: true });
   }
   async listEnvironments(skipInitializationCheck = false) {
@@ -282793,7 +283725,7 @@ class EnvironmentStore {
     let entryCount = 0;
     let totalUncompressedBytes = 0;
     await import_extract_zip.default(absoluteEnvironmentPath, {
-      dir: path9.resolve(unzippedEnvironmentPath),
+      dir: path10.resolve(unzippedEnvironmentPath),
       onEntry: (entry) => {
         entryCount += 1;
         totalUncompressedBytes += entry.uncompressedSize ?? 0;
@@ -282901,7 +283833,7 @@ class EnvironmentStore {
     return absoluteEnvironmentPath;
   }
   isLocalPath(location) {
-    return location.startsWith("./") || location.startsWith("../") || location.startsWith("~/") || location.startsWith("/") || path9.isAbsolute(location);
+    return location.startsWith("./") || location.startsWith("../") || location.startsWith("~/") || location.startsWith("/") || path10.isAbsolute(location);
   }
   resolveLocalPath(location) {
     return resolvePackageLocation(location, getPublisherConfigDir(this.serverRootPath) ?? this.serverRootPath);
@@ -282998,7 +283930,7 @@ class EnvironmentStore {
             const isInPlace = this.inPlaceEnvs.has(environmentName) && this.isLocalPath(_package.location);
             if (isInPlace) {
               await clearMountTarget(absolutePackagePath);
-              const absoluteSourcePath = path9.resolve(sourcePath);
+              const absoluteSourcePath = path10.resolve(sourcePath);
               const linkType = process.platform === "win32" ? "junction" : "dir";
               try {
                 await fs9.promises.symlink(absoluteSourcePath, absolutePackagePath, linkType);
@@ -283157,7 +284089,7 @@ class EnvironmentStore {
       if (file.name.endsWith("/")) {
         return;
       }
-      await fs9.promises.mkdir(path9.dirname(absoluteFilePath), {
+      await fs9.promises.mkdir(path10.dirname(absoluteFilePath), {
         recursive: true
       });
       return fs9.promises.writeFile(absoluteFilePath, await file.download());
@@ -283174,7 +284106,7 @@ class EnvironmentStore {
     const prefix = prefixParts.join("/");
     if (isCompressedFile) {
       const zipFilePath = `${absoluteDirPath}.zip`;
-      await fs9.promises.mkdir(path9.dirname(zipFilePath), {
+      await fs9.promises.mkdir(path10.dirname(zipFilePath), {
         recursive: true
       });
       const command = new import_client_s33.GetObjectCommand({
@@ -283214,7 +284146,7 @@ class EnvironmentStore {
         return;
       }
       const absoluteFilePath = safeJoinUnderRoot(absoluteDirPath, relativeFilePath);
-      await fs9.promises.mkdir(path9.dirname(absoluteFilePath), {
+      await fs9.promises.mkdir(path10.dirname(absoluteFilePath), {
         recursive: true
       });
       const command = new import_client_s33.GetObjectCommand({
@@ -283368,7 +284300,7 @@ class WatchModeController {
       ignored: (filePath, stats) => {
         if (!stats?.isFile())
           return false;
-        const ext = path10.extname(filePath).toLowerCase();
+        const ext = path11.extname(filePath).toLowerCase();
         return !MODEL_EXTS.has(ext) && !ASSET_EXTS.has(ext);
       },
       ignoreInitial: true
@@ -283386,12 +284318,12 @@ class WatchModeController {
     };
     const onEvent = (kind) => async (filePath) => {
       logger.info(`Watch ${kind}: ${filePath}; environment=${watchName}`);
-      const rel = path10.relative(this.watchingPath ?? "", filePath);
-      const segments = rel.split(path10.sep);
+      const rel = path11.relative(this.watchingPath ?? "", filePath);
+      const segments = rel.split(path11.sep);
       const pkgName = segments.length > 1 && segments[0] && !segments[0].startsWith("..") ? segments[0] : null;
       if (!pkgName)
         return;
-      const ext = path10.extname(filePath).toLowerCase();
+      const ext = path11.extname(filePath).toLowerCase();
       if (MODEL_EXTS.has(ext)) {
         const recompiled = await reloadPackage(pkgName);
         if (!recompiled)
@@ -283614,6 +284546,12 @@ class MaterializationController {
       }
       result.forceRefresh = body.forceRefresh;
     }
+    if (body.reseed !== undefined) {
+      if (typeof body.reseed !== "boolean") {
+        throw new BadRequestError("reseed must be a boolean");
+      }
+      result.reseed = body.reseed;
+    }
     if (body.sourceNames !== undefined) {
       if (!Array.isArray(body.sourceNames) || body.sourceNames.some((n) => typeof n !== "string")) {
         throw new BadRequestError("sourceNames must be an array of strings");
@@ -283707,13 +284645,17 @@ class MaterializationController {
     if (instruction.realization !== "COPY" && instruction.realization !== "SNAPSHOT") {
       throw new BadRequestError("Build instruction 'realization' must be COPY or SNAPSHOT");
     }
+    if (instruction.reseed !== undefined && typeof instruction.reseed !== "boolean") {
+      throw new BadRequestError("Build instruction 'reseed' must be a boolean");
+    }
     return {
       sourceEntityId: instruction.sourceEntityId,
       sourceID: typeof instruction.sourceID === "string" ? instruction.sourceID : undefined,
       materializedTableId: instruction.materializedTableId,
       physicalTableName: instruction.physicalTableName,
       realization: instruction.realization,
-      ...typeof instruction.destination === "string" ? { destination: instruction.destination } : {}
+      ...typeof instruction.destination === "string" ? { destination: instruction.destination } : {},
+      ...typeof instruction.reseed === "boolean" ? { reseed: instruction.reseed } : {}
     };
   }
   async stopMaterialization(environmentName, packageName, materializationId) {
@@ -286351,22 +287293,22 @@ async function getModelForQuery(environmentStore, environmentName, packageName,
   }
 }
 function buildMalloyUri(components, fragment) {
-  let path11 = "/environment/";
+  let path12 = "/environment/";
   if (components.environment) {
-    path11 += encodeURIComponent(components.environment);
+    path12 += encodeURIComponent(components.environment);
   } else {
-    path11 += "home";
+    path12 += "home";
   }
   if (components.package) {
-    path11 += "/package/" + encodeURIComponent(components.package);
+    path12 += "/package/" + encodeURIComponent(components.package);
   }
   if (components.resourceType) {
-    path11 += "/" + components.resourceType;
+    path12 += "/" + components.resourceType;
     if (components.resourceName) {
-      path11 += "/" + encodeURIComponent(components.resourceName);
+      path12 += "/" + encodeURIComponent(components.resourceName);
     }
   }
-  let uriString = "malloy:/" + path11;
+  let uriString = "malloy:/" + path12;
   if (fragment) {
     uriString += "#" + fragment;
   }
@@ -290970,7 +291912,7 @@ function initializeMcpServer(environmentStore) {
 // src/mcp_config.ts
 import * as fs10 from "fs";
 import * as os3 from "os";
-import * as path11 from "path";
+import * as path12 from "path";
 init_logger();
 var MCP_CONFIG_FILENAME = ".mcp.json";
 function malloyServer(endpoint) {
@@ -290995,11 +291937,11 @@ function mcpEndpoint(host, port) {
   return `http://${host}:${port}/mcp`;
 }
 function findGitWorkTreeRoot(dir) {
-  let current = path11.resolve(dir);
+  let current = path12.resolve(dir);
   for (;; ) {
-    if (fs10.existsSync(path11.join(current, ".git")))
+    if (fs10.existsSync(path12.join(current, ".git")))
       return current;
-    const parent = path11.dirname(current);
+    const parent = path12.dirname(current);
     if (parent === current)
       return;
     current = parent;
@@ -291010,7 +291952,7 @@ function mcpConfigEnabled() {
 }
 function ensureMcpConfig(options) {
   const { dir, endpoint, requestedPort, boundPort, homeDir } = options;
-  const file = path11.join(dir, MCP_CONFIG_FILENAME);
+  const file = path12.join(dir, MCP_CONFIG_FILENAME);
   try {
     const existing = (() => {
       try {
@@ -291037,18 +291979,18 @@ function ensureMcpConfig(options) {
       try {
         return fs10.realpathSync(p);
       } catch {
-        return path11.resolve(p);
+        return path12.resolve(p);
       }
     };
     if (realish(dir) === realish(homeDir ?? os3.homedir())) {
       return { action: "skipped-home", dir, endpoint, staleConfig };
     }
-    if (path11.resolve(dir) === path11.parse(path11.resolve(dir)).root) {
+    if (path12.resolve(dir) === path12.parse(path12.resolve(dir)).root) {
       return { action: "skipped-root", dir, endpoint, staleConfig };
     }
     const gitRoot = findGitWorkTreeRoot(dir);
     if (gitRoot !== undefined) {
-      const rootCandidate = path11.join(gitRoot, MCP_CONFIG_FILENAME);
+      const rootCandidate = path12.join(gitRoot, MCP_CONFIG_FILENAME);
       return {
         action: "skipped-git",
         dir,
@@ -291778,6 +292720,137 @@ init_errors();
 init_logger();
 import { Manifest } from "@malloydata/malloy";
 
+// src/service/incremental_build.ts
+init_logger();
+function incrementalLineage(params) {
+  const d = params.declaration;
+  if (!d?.incremental)
+    return;
+  const watermark = d.watermark;
+  if (watermark === undefined || watermark.kind !== "dimension" || !d.watermarkOrderable || !isRenderableWatermarkType(watermark.malloyType) || d.strategy === undefined) {
+    return;
+  }
+  if (!INCREMENTAL_DIALECT_ALLOWLIST.has(params.dialect))
+    return;
+  if (params.isStorageBuild)
+    return;
+  const mergeKeys = d.mergeKeys.filter((k) => k.kind === "dimension").map((k) => k.name);
+  if (mergeKeys.length !== d.mergeKeys.length)
+    return;
+  return {
+    physicalTableName: params.physicalTableName,
+    connectionName: params.connectionName,
+    watermarkName: watermark.name,
+    watermarkType: watermark.malloyType,
+    mergeKeys,
+    strategy: d.strategy
+  };
+}
+async function planSourceRefresh(params) {
+  const { context, lineage } = params;
+  let ledgerEntry = null;
+  try {
+    ledgerEntry = await context.ledger.getIncrementalLedgerEntry(context.environmentId, context.packageName, params.sourceEntityId);
+  } catch (err) {
+    return {
+      mode: "seed",
+      reasonCode: "ledger_unreadable",
+      reason: `the covered_through ledger could not be read (${errMessage(err)})`
+    };
+  }
+  const postgresVersionNum = lineage.strategy === "merge" && params.persistSource.dialectName === "postgres" && ledgerEntry !== null ? await probePostgresVersion(params.runner) : undefined;
+  try {
+    return await planIncrementalStep({
+      runner: params.runner,
+      dialect: params.persistSource.dialectName,
+      quotedTablePath: params.quotedTablePath,
+      lineage,
+      ledgerEntry,
+      forceRefresh: context.forceRefresh || params.reseed === true,
+      now: context.now,
+      sourceSQL: params.sourceSQL,
+      columns: params.columns,
+      postgresVersionNum
+    });
+  } catch (err) {
+    return {
+      mode: "seed",
+      reasonCode: "plan_error",
+      reason: `the delta could not be planned (${errMessage(err)})`
+    };
+  }
+}
+async function advanceLedger(params) {
+  const { context, lineage } = params;
+  try {
+    await context.ledger.upsertIncrementalLedgerEntry({
+      environmentId: context.environmentId,
+      packageName: context.packageName,
+      sourceEntityId: params.sourceEntityId,
+      coveredThroughValue: params.coveredThrough.value,
+      coveredThroughType: params.coveredThrough.malloyType,
+      watermarkDimension: lineage.watermarkName,
+      mergeKeyDimensions: lineage.mergeKeys,
+      derivedStrategy: lineage.strategy,
+      physicalTableName: lineage.physicalTableName,
+      connectionName: lineage.connectionName,
+      advancedByMaterializationId: context.materializationId
+    });
+  } catch (err) {
+    logger.warn("Failed to advance the covered_through boundary", {
+      packageName: context.packageName,
+      sourceEntityId: params.sourceEntityId,
+      error: errMessage(err)
+    });
+  }
+}
+async function resetLedger(context, sourceEntityId) {
+  try {
+    await context.ledger.deleteIncrementalLedgerEntry(context.environmentId, context.packageName, sourceEntityId);
+  } catch (err) {
+    logger.warn("Failed to clear the covered_through boundary", {
+      packageName: context.packageName,
+      sourceEntityId,
+      error: errMessage(err)
+    });
+  }
+}
+async function advanceLedgerAfterSeed(params) {
+  const boundary = await seedCoveredThrough(params.runner, params.dialect, params.lineage, params.quotedTablePath, params.context.now);
+  if (!boundary.bound) {
+    if (boundary.error) {
+      logger.warn("Could not read a covered_through boundary after a full rebuild; " + "the next refresh will rebuild again", {
+        packageName: params.context.packageName,
+        sourceEntityId: params.sourceEntityId,
+        error: boundary.error
+      });
+    }
+    return;
+  }
+  await advanceLedger({
+    context: params.context,
+    lineage: params.lineage,
+    sourceEntityId: params.sourceEntityId,
+    coveredThrough: boundary.bound
+  });
+  return boundary.bound;
+}
+function reportIncrementalStep(params) {
+  const { step, sourceName, packageName, physicalTableName } = params;
+  recordIncrementalStep(step.mode, step.reasonCode);
+  logger.warn(step.mode === "seed" ? "Rebuilding an incremental source in full" : "Skipping an incremental source's refresh", {
+    packageName,
+    sourceName,
+    physicalTableName,
+    reasonCode: step.reasonCode,
+    reason: step.reason
+  });
+}
+function reportDeltaApplied(params) {
+  recordIncrementalStep("delta");
+  logger.info("Applied an incremental delta", params);
+}
+
 // src/service/materialization_build_session.ts
 init_errors();
 init_logger();
@@ -291789,7 +292862,7 @@ import {
 } from "@malloydata/malloy";
 import { mkdirSync as mkdirSync2, mkdtempSync, rmSync } from "node:fs";
 import os4 from "node:os";
-import path12 from "node:path";
+import path13 from "node:path";
 var sharedGateSession;
 var PASSTHROUGH_SOURCE_TYPES = [
   "bigquery",
@@ -291821,7 +292894,7 @@ function passthroughSourceType(sourceConnection) {
   throw new BadRequestError(`Cannot materialize a '${type}' source into a storage destination: the ` + `native query-passthrough build supports source connections of type ` + `${PASSTHROUGH_SOURCE_TYPES.join(", ")} only.`);
 }
 function createIsolatedBuildSession(sessionName) {
-  const workDir = mkdtempSync(path12.join(os4.tmpdir(), "malloy-build-"));
+  const workDir = mkdtempSync(path13.join(os4.tmpdir(), "malloy-build-"));
   let session;
   try {
     session = new DuckDBConnection4(sessionName, ":memory:", workDir);
@@ -291979,7 +293052,7 @@ async function attachDestinationReadWrite(session, destinationName, destinationC
   }
   const destinationRoot = storageDestinationRoot(environmentPath);
   mkdirSync2(destinationRoot, { recursive: true });
-  const dbPath = path12.join(destinationRoot, `${destinationName}.duckdb`);
+  const dbPath = path13.join(destinationRoot, `${destinationName}.duckdb`);
   await session.runSQL(`ATTACH '${escapeSQL(dbPath)}' AS ${quoteIdentifier(destinationName, "duckdb")}`);
 }
 function assertSupportedDestination(destinationName, destinationConnection) {
@@ -292041,6 +293114,9 @@ async function resolveEnvironmentId(repository, environmentName) {
 }
 
 // src/service/materialization_service.ts
+function boundaryFields(bound) {
+  return bound ? { coveredThrough: bound.value, coveredThroughType: bound.malloyType } : {};
+}
 function connectionMetadataLayers(environment, connectionName) {
   try {
     const connection = environment.getApiConnection(connectionName);
@@ -292189,9 +293265,11 @@ class MaterializationService {
       throw this.activeConflict(packageName, active2.id);
     }
     const forceRefresh = options.forceRefresh ?? false;
+    const reseed = options.reseed ?? false;
     const trigger = options.trigger ?? "ON_DEMAND";
     const metadata = {
       forceRefresh,
+      reseed,
       sourceNames: options.sourceNames ?? null,
       mode: orchestrated ? "orchestrated" : "auto",
       trigger
@@ -292209,6 +293287,7 @@ class MaterializationService {
     this.runInBackground(created.id, (signal) => this.runBuild(created.id, environmentName, packageName, {
       sourceNames: options.sourceNames,
       forceRefresh,
+      reseed,
       buildInstructions,
       referenceManifest: options.referenceManifest,
       strictUpstreams: options.strictUpstreams,
@@ -292241,6 +293320,13 @@ class MaterializationService {
           message: `Source(s) ${names} are annotated '#@ persist' but were not ` + `recognized as a materializable source, so nothing would be ` + `built (they would be served live). Only query/aggregate ` + `sources materialize; a filtered pass-through does not. Persist ` + `a query source, or invoke a parameterized source with a bound ` + `argument, or drop the annotation to serve live.`
         });
       }
+      const incremental = this.incrementalRunContext(compiled, {
+        environmentId,
+        packageName,
+        materializationId: id,
+        forceRefresh: opts.reseed ?? false,
+        now: new Date(startedAt)
+      });
       let instructions;
       let carried;
       if (orchestrated) {
@@ -292252,7 +293338,7 @@ class MaterializationService {
         }
       } else {
         const priorEntries = opts.forceRefresh ? {} : await this.getMostRecentManifestEntries(environmentId, packageName, id);
-        ({ instructions, carried } = this.deriveSelfInstructions(compiled, opts.sourceNames, priorEntries));
+        ({ instructions, carried } = this.deriveSelfInstructions(compiled, opts.sourceNames, priorEntries, incremental));
       }
       const entries = await this.executeInstructedBuild(compiled, environment, instructions, carried, signal, opts.strictUpstreams ?? false, orchestrated ? { environmentId, packageName } : undefined, {
         packageMaterialization: pkg.getMaterializationConfig?.() ?? null,
@@ -292263,7 +293349,7 @@ class MaterializationService {
           trigger: opts.runContext?.trigger ?? opts.trigger?.toLowerCase(),
           runId: opts.runContext?.runId ?? id
         }
-      });
+      }, incremental);
       const sourcesBuilt = instructions.length;
       const sourcesReused = Object.keys(carried).length;
       const durationMs = Date.now() - startedAt;
@@ -292295,7 +293381,7 @@ class MaterializationService {
       throw err;
     }
   }
-  deriveSelfInstructions(compiled, sourceNames, priorEntries) {
+  deriveSelfInstructions(compiled, sourceNames, priorEntries, incremental) {
     const include = sourceNames ? new Set(sourceNames) : null;
     const instructions = [];
     const carried = {};
@@ -292315,12 +293401,19 @@ class MaterializationService {
         if (seen.has(sourceEntityId))
           continue;
         seen.add(sourceEntityId);
+        const logicalName = selfAssignTableName(persistSource);
+        const deltaEligible = incremental !== undefined && incrementalLineage({
+          declaration: incremental.declarations[persistSource.sourceID],
+          dialect: persistSource.dialectName,
+          physicalTableName: logicalName,
+          connectionName: persistSource.connectionName,
+          isStorageBuild: destination !== undefined
+        }) !== undefined;
         const prior = priorEntries[sourceEntityId];
-        if (prior && prior.physicalTableName && (prior.storageDestinationName ?? undefined) === destination) {
+        if (!deltaEligible && prior && prior.physicalTableName && (prior.storageDestinationName ?? undefined) === destination) {
           carried[sourceEntityId] = prior;
           continue;
         }
-        const logicalName = selfAssignTableName(persistSource);
         instructions.push({
           sourceEntityId,
           materializedTableId: `local-${sourceEntityId.substring(0, STAGING_ID_LEN)}`,
@@ -292476,7 +293569,17 @@ class MaterializationService {
     }
     return quoteManifestTablePath(physicalTableName, connection.dialectName);
   }
-  async executeInstructedBuild(compiled, environment, instructions, seedEntries, signal, strict = false, owner, buildMetadata) {
+  incrementalRunContext(compiled, run) {
+    const declarations = {};
+    for (const [sourceID, declaration] of Object.entries(collectIncrementalDeclarations(compiled.sources))) {
+      if (declaration.incremental)
+        declarations[sourceID] = declaration;
+    }
+    if (Object.keys(declarations).length === 0)
+      return;
+    return { ...run, declarations, ledger: this.repository };
+  }
+  async executeInstructedBuild(compiled, environment, instructions, seedEntries, signal, strict = false, owner, buildMetadata, incremental) {
     const { graphs, sources, connectionDigests, connections } = compiled;
     const bySourceID = new Map;
     const bySourceEntityId = new Map;
@@ -292515,10 +293618,13 @@ class MaterializationService {
           const instruction = orchestratedInstruction ?? bySourceEntityId.get(sourceEntityId);
           if (!instruction)
             continue;
+          if (instruction.destination && getPersistStorageMode() === "off") {
+            throw new BadRequestError(`Source '${persistSource.name}' was instructed to build into ` + `storage destination '${instruction.destination}', but ` + `PERSIST_STORAGE_MODE is off, so no destination can be ` + `written. Refusing rather than building the table into the ` + `source warehouse instead.`);
+          }
           if (!orchestratedInstruction && instruction.destination && getPersistStorageMode() !== "off") {
             assertMaterializationEligible(persistSource);
           }
-          const entry = await this.buildOneSource(persistSource, instruction, connection, connectionDigests, manifest, environment, entries, buildMetadata);
+          const entry = await this.buildOneSource(persistSource, instruction, connection, connectionDigests, manifest, environment, entries, buildMetadata, incremental, sourceEntityId);
           entries[sourceEntityId] = entry;
           if (entry.storageDestinationName)
             builtThisRun.push(entry);
@@ -292628,11 +293734,12 @@ class MaterializationService {
     });
     return resolved.metadata ? { queryMetadata: resolved.metadata } : {};
   }
-  async buildOneSource(persistSource, instruction, connection, connectionDigests, manifest, environment, builtEntries, buildMetadata) {
+  async buildOneSource(persistSource, instruction, connection, connectionDigests, manifest, environment, builtEntries, buildMetadata, incremental, contentSourceEntityId) {
     const sourceEntityId = instruction.sourceEntityId;
     const physicalTableName = instruction.physicalTableName;
     const isStorageBuild = !!instruction.destination && getPersistStorageMode() !== "off";
-    const buildManifest = manifestExcludingStorage(manifest, builtEntries);
+    const reducedManifest = manifestExcludingStorage(manifest, builtEntries);
+    const buildManifest = isStorageBuild ? { ...reducedManifest, strict: false } : reducedManifest;
     const buildSQL = persistSource.getSQL({
       buildManifest,
       connectionDigests
@@ -292646,12 +293753,42 @@ class MaterializationService {
       return this.buildOneSourceIntoStorage(persistSource, instruction, manifest, environment, publicBuildSQL, builtEntries, dependsOnStorageUpstream);
     }
     const runOptions = this.buildRunSQLOptions(persistSource, environment, buildMetadata);
+    const dialect = persistSource.dialectName;
+    const quotedPhysicalPath = quoteTablePath(physicalTableName, dialect);
+    const lineage = incremental && contentSourceEntityId ? incrementalLineage({
+      declaration: incremental.declarations[persistSource.sourceID],
+      dialect,
+      physicalTableName,
+      connectionName: persistSource.connectionName,
+      isStorageBuild
+    }) : undefined;
+    const incrementalRefresh = incremental && lineage && contentSourceEntityId ? {
+      context: incremental,
+      lineage,
+      ledgerKey: contentSourceEntityId
+    } : undefined;
+    if (incrementalRefresh) {
+      const applied = await this.refreshOneSourceIncrementally({
+        ...incrementalRefresh,
+        persistSource,
+        instruction,
+        connection,
+        buildSQL,
+        quotedTablePath: quotedPhysicalPath,
+        runOptions,
+        manifest
+      });
+      if (applied)
+        return applied;
+    }
     const bareName = bareTableName(physicalTableName);
     const stagingTableName = `${physicalTableName}${stagingSuffix(sourceEntityId)}`;
-    const dialect = persistSource.dialectName;
     const quotedStaging = quoteTablePath(stagingTableName, dialect);
-    const quotedPhysical = quoteTablePath(physicalTableName, dialect);
+    const quotedPhysical = quotedPhysicalPath;
     const quotedBareName = quoteIdentifier(bareName, dialect);
+    if (incrementalRefresh) {
+      await resetLedger(incrementalRefresh.context, incrementalRefresh.ledgerKey);
+    }
     const startTime = performance.now();
     await connection.runSQL(`DROP TABLE IF EXISTS ${quotedStaging}`, runOptions);
     try {
@@ -292677,6 +293814,14 @@ class MaterializationService {
       physicalTableName,
       durationMs
     });
+    const seededThrough = incrementalRefresh ? await advanceLedgerAfterSeed({
+      context: incrementalRefresh.context,
+      lineage: incrementalRefresh.lineage,
+      sourceEntityId: incrementalRefresh.ledgerKey,
+      quotedTablePath: quotedPhysical,
+      dialect,
+      runner: (sql) => connection.runSQL(sql, runOptions)
+    }) : undefined;
     return {
       sourceEntityId,
       sourceName: persistSource.name,
@@ -292684,9 +293829,70 @@ class MaterializationService {
       physicalTableName,
       connectionName: persistSource.connectionName,
       realization: instruction.realization,
+      ...boundaryFields(seededThrough),
       rowCount: null
     };
   }
+  async refreshOneSourceIncrementally(params) {
+    const { context, lineage, persistSource, instruction } = params;
+    const sourceEntityId = instruction.sourceEntityId;
+    const dialect = persistSource.dialectName;
+    const runner = (sql) => params.connection.runSQL(sql, params.runOptions);
+    const step = await planSourceRefresh({
+      context,
+      lineage,
+      persistSource,
+      sourceEntityId: params.ledgerKey,
+      quotedTablePath: params.quotedTablePath,
+      sourceSQL: params.buildSQL,
+      columns: deriveColumns(persistSource).map((c) => String(c.name)),
+      reseed: instruction.reseed,
+      runner
+    });
+    if (step.mode !== "delta") {
+      reportIncrementalStep({
+        step,
+        sourceName: persistSource.name,
+        packageName: context.packageName,
+        physicalTableName: lineage.physicalTableName
+      });
+    }
+    if (step.mode === "seed")
+      return;
+    const startTime = performance.now();
+    if (step.mode === "delta") {
+      await applyDeltaScript(runner, dialect, step.statements);
+      await advanceLedger({
+        context,
+        lineage,
+        sourceEntityId: params.ledgerKey,
+        coveredThrough: step.coveredThrough
+      });
+      const durationMs = Math.round(performance.now() - startTime);
+      recordSourceBuildDuration(durationMs, "delta");
+      reportDeltaApplied({
+        packageName: context.packageName,
+        sourceName: persistSource.name,
+        physicalTableName: lineage.physicalTableName,
+        rangeStart: step.start.value,
+        rangeEnd: step.end.value,
+        durationMs
+      });
+    }
+    params.manifest.update(sourceEntityId, {
+      tableName: params.quotedTablePath
+    });
+    return {
+      sourceEntityId,
+      sourceName: persistSource.name,
+      materializedTableId: instruction.materializedTableId,
+      physicalTableName: lineage.physicalTableName,
+      connectionName: persistSource.connectionName,
+      realization: instruction.realization,
+      rowCount: null,
+      ...boundaryFields(step.coveredThrough)
+    };
+  }
   async buildOneSourceIntoStorage(persistSource, instruction, manifest, environment, buildSQL, builtEntries, dependsOnStorageUpstream) {
     const sourceEntityId = instruction.sourceEntityId;
     const physicalTableName = instruction.physicalTableName;
@@ -293393,8 +294599,8 @@ var MCP_ENDPOINT = "/mcp";
 var SHUTDOWN_DRAIN_DURATION_SECONDS = Number(process.env.SHUTDOWN_DRAIN_DURATION_SECONDS || 0);
 var SHUTDOWN_GRACEFUL_CLOSE_TIMEOUT_SECONDS = Number(process.env.SHUTDOWN_GRACEFUL_CLOSE_TIMEOUT_SECONDS || 0);
 var __filename_esm = fileURLToPath7(import.meta.url);
-var ROOT = path13.join(path13.dirname(__filename_esm), "app");
-var SERVER_ROOT = path13.resolve(process.cwd(), process.env.SERVER_ROOT || ".");
+var ROOT = path14.join(path14.dirname(__filename_esm), "app");
+var SERVER_ROOT = path14.resolve(process.cwd(), process.env.SERVER_ROOT || ".");
 var API_PREFIX2 = "/api/v0";
 var isDevelopment = process.env["NODE_ENV"] === "development";
 var app = import_express.default();
@@ -293492,7 +294698,7 @@ mcpApp.all(MCP_ENDPOINT, async (req, res) => {
     }
   }
 });
-var PUBLISHER_RUNTIME_PATH = path13.join(path13.dirname(__filename_esm), "runtime", "publisher.js");
+var PUBLISHER_RUNTIME_PATH = path14.join(path14.dirname(__filename_esm), "runtime", "publisher.js");
 app.get("/sdk/publisher.js", (_req, res) => {
   res.type("application/javascript");
   res.setHeader("cache-control", "public, max-age=60");
@@ -293521,7 +294727,7 @@ async function serveFromPackage(req, res) {
   try {
     const environment = await environmentStore.getEnvironment(req.params.environmentName, false);
     const pkg = await environment.getPackage(req.params.packageName, false);
-    const publicRoot = path13.join(pkg.getPackagePath(), "public");
+    const publicRoot = path14.join(pkg.getPackagePath(), "public");
     let subPath = subPathRaw;
     if (subPath === "" || subPath.endsWith("/")) {
       subPath = subPath + "index.html";
@@ -293539,12 +294745,12 @@ async function serveFromPackage(req, res) {
       }
       return;
     }
-    const rel = path13.relative(realPublicRoot, realFullPath);
-    if (rel.startsWith("..") || path13.isAbsolute(rel)) {
+    const rel = path14.relative(realPublicRoot, realFullPath);
+    if (rel.startsWith("..") || path14.isAbsolute(rel)) {
       res.status(403).end();
       return;
     }
-    const ext = path13.extname(realFullPath).toLowerCase();
+    const ext = path14.extname(realFullPath).toLowerCase();
     if (ext === ".html" || ext === ".htm") {
       const frameAncestors = process.env.PUBLISHER_FRAME_ANCESTORS || "*";
       res.setHeader("Content-Security-Policy", `frame-ancestors ${frameAncestors}`);
@@ -293610,20 +294816,20 @@ async function listPackagePages(environmentName, packageName, publicRoot) {
     for (const entry of entries) {
       if (entry.name.startsWith(".") || entry.name === "node_modules")
         continue;
-      const full = path13.join(dir, entry.name);
+      const full = path14.join(dir, entry.name);
       let realFull;
       try {
         realFull = await fs11.realpath(full);
       } catch {
         continue;
       }
-      const contained = path13.relative(realPublicRoot, realFull);
-      if (contained.startsWith("..") || path13.isAbsolute(contained))
+      const contained = path14.relative(realPublicRoot, realFull);
+      if (contained.startsWith("..") || path14.isAbsolute(contained))
         continue;
       if (entry.isDirectory()) {
         await walk(full, depth + 1);
       } else if (entry.isFile() && (entry.name.endsWith(".html") || entry.name.endsWith(".htm"))) {
-        const rel = path13.relative(publicRoot, full).replace(/\\/g, "/");
+        const rel = path14.relative(publicRoot, full).replace(/\\/g, "/");
         let title = rel;
         let fit;
         try {
@@ -293668,14 +294874,14 @@ async function listPackagePages(environmentName, packageName, publicRoot) {
 }
 if (!isDevelopment) {
   app.use("/", import_express.default.static(ROOT));
-  app.use("/api-doc.html", import_express.default.static(path13.join(ROOT, "api-doc.html")));
+  app.use("/api-doc.html", import_express.default.static(path14.join(ROOT, "api-doc.html")));
 } else {
   app.use(`${API_PREFIX2}`, loggerMiddleware);
   app.use(import_http_proxy_middleware.createProxyMiddleware({
     target: "http://localhost:5173",
     changeOrigin: true,
     ws: true,
-    pathFilter: (path14) => !path14.startsWith("/api/") && !path14.startsWith("/metrics") && !path14.startsWith("/health")
+    pathFilter: (path15) => !path15.startsWith("/api/") && !path15.startsWith("/metrics") && !path15.startsWith("/health")
   }));
 }
 var setVersionIdError2 = (res) => {
@@ -293700,7 +294906,7 @@ app.get(`${API_PREFIX2}/environments/:environmentName/packages/:packageName/page
   try {
     const environment = await environmentStore.getEnvironment(req.params.environmentName, false);
     const pkg = await environment.getPackage(req.params.packageName, false);
-    const pages = await listPackagePages(req.params.environmentName, req.params.packageName, path13.join(pkg.getPackagePath(), "public"));
+    const pages = await listPackagePages(req.params.environmentName, req.params.packageName, path14.join(pkg.getPackagePath(), "public"));
     res.json(pages);
   } catch (error) {
     logger.error("Failed to list package pages", { error });
@@ -294315,7 +295521,7 @@ registerLegacyRoutes(app, {
   materializationController
 });
 if (!isDevelopment) {
-  const SPA_INDEX = path13.resolve(ROOT, "index.html");
+  const SPA_INDEX = path14.resolve(ROOT, "index.html");
   const escapeHtml = (value) => value.replace(/[<>&]/g, (c) => ({ "<": "&lt;", ">": "&gt;", "&": "&amp;" })[c] ?? c);
   const decodeSegment = (segment) => {
     if (segment === undefined)