@promptscript/cli 1.4.1 → 1.4.3

package/index.js

@@ -1,12 +1,1584 @@
+var __create = Object.create;
 var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __esm = (fn, res) => function __init() {
   return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
 };
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
 };
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// node_modules/.pnpm/fastify-plugin@5.1.0/node_modules/fastify-plugin/lib/getPluginName.js
+var require_getPluginName = __commonJS({
+  "node_modules/.pnpm/fastify-plugin@5.1.0/node_modules/fastify-plugin/lib/getPluginName.js"(exports2, module2) {
+    "use strict";
+    var fpStackTracePattern = /at\s(?:.*\.)?plugin\s.*\n\s*(.*)/;
+    var fileNamePattern = /(\w*(\.\w*)*)\..*/;
+    module2.exports = function getPluginName(fn) {
+      if (fn.name.length > 0) return fn.name;
+      const stackTraceLimit = Error.stackTraceLimit;
+      Error.stackTraceLimit = 10;
+      try {
+        throw new Error("anonymous function");
+      } catch (e) {
+        Error.stackTraceLimit = stackTraceLimit;
+        return extractPluginName(e.stack);
+      }
+    };
+    function extractPluginName(stack) {
+      const m = stack.match(fpStackTracePattern);
+      return m ? m[1].split(/[/\\]/).slice(-1)[0].match(fileNamePattern)[1] : "anonymous";
+    }
+    module2.exports.extractPluginName = extractPluginName;
+  }
+});
+
+// node_modules/.pnpm/fastify-plugin@5.1.0/node_modules/fastify-plugin/lib/toCamelCase.js
+var require_toCamelCase = __commonJS({
+  "node_modules/.pnpm/fastify-plugin@5.1.0/node_modules/fastify-plugin/lib/toCamelCase.js"(exports2, module2) {
+    "use strict";
+    module2.exports = function toCamelCase(name) {
+      if (name[0] === "@") {
+        name = name.slice(1).replace("/", "-");
+      }
+      return name.replace(/-(.)/g, function(match, g1) {
+        return g1.toUpperCase();
+      });
+    };
+  }
+});
+
+// node_modules/.pnpm/fastify-plugin@5.1.0/node_modules/fastify-plugin/plugin.js
+var require_plugin = __commonJS({
+  "node_modules/.pnpm/fastify-plugin@5.1.0/node_modules/fastify-plugin/plugin.js"(exports2, module2) {
+    "use strict";
+    var getPluginName = require_getPluginName();
+    var toCamelCase = require_toCamelCase();
+    var count = 0;
+    function plugin(fn, options = {}) {
+      let autoName = false;
+      if (fn.default !== void 0) {
+        fn = fn.default;
+      }
+      if (typeof fn !== "function") {
+        throw new TypeError(
+          `fastify-plugin expects a function, instead got a '${typeof fn}'`
+        );
+      }
+      if (typeof options === "string") {
+        options = {
+          fastify: options
+        };
+      }
+      if (typeof options !== "object" || Array.isArray(options) || options === null) {
+        throw new TypeError("The options object should be an object");
+      }
+      if (options.fastify !== void 0 && typeof options.fastify !== "string") {
+        throw new TypeError(`fastify-plugin expects a version string, instead got '${typeof options.fastify}'`);
+      }
+      if (!options.name) {
+        autoName = true;
+        options.name = getPluginName(fn) + "-auto-" + count++;
+      }
+      fn[/* @__PURE__ */ Symbol.for("skip-override")] = options.encapsulate !== true;
+      fn[/* @__PURE__ */ Symbol.for("fastify.display-name")] = options.name;
+      fn[/* @__PURE__ */ Symbol.for("plugin-meta")] = options;
+      if (!fn.default) {
+        fn.default = fn;
+      }
+      const camelCase = toCamelCase(options.name);
+      if (!autoName && !fn[camelCase]) {
+        fn[camelCase] = fn;
+      }
+      return fn;
+    }
+    module2.exports = plugin;
+    module2.exports.default = plugin;
+    module2.exports.fastifyPlugin = plugin;
+  }
+});
+
+// node_modules/.pnpm/@lukeed+ms@2.0.2/node_modules/@lukeed/ms/dist/index.js
+var require_dist = __commonJS({
+  "node_modules/.pnpm/@lukeed+ms@2.0.2/node_modules/@lukeed/ms/dist/index.js"(exports2) {
+    "use strict";
+    var RGX = /^(-?(?:\d+)?\.?\d+) *(m(?:illiseconds?|s(?:ecs?)?))?(s(?:ec(?:onds?|s)?)?)?(m(?:in(?:utes?|s)?)?)?(h(?:ours?|rs?)?)?(d(?:ays?)?)?(w(?:eeks?|ks?)?)?(y(?:ears?|rs?)?)?$/;
+    var SEC = 1e3;
+    var MIN = SEC * 60;
+    var HOUR = MIN * 60;
+    var DAY = HOUR * 24;
+    var YEAR = DAY * 365.25;
+    function parse2(val) {
+      var num, arr = val.toLowerCase().match(RGX);
+      if (arr != null && (num = parseFloat(arr[1]))) {
+        if (arr[3] != null) return num * SEC;
+        if (arr[4] != null) return num * MIN;
+        if (arr[5] != null) return num * HOUR;
+        if (arr[6] != null) return num * DAY;
+        if (arr[7] != null) return num * DAY * 7;
+        if (arr[8] != null) return num * YEAR;
+        return num;
+      }
+    }
+    function fmt(val, pfx, str, long) {
+      var num = (val | 0) === val ? val : ~~(val + 0.5);
+      return pfx + num + (long ? " " + str + (num != 1 ? "s" : "") : str[0]);
+    }
+    function format2(num, long) {
+      var pfx = num < 0 ? "-" : "", abs = num < 0 ? -num : num;
+      if (abs < SEC) return num + (long ? " ms" : "ms");
+      if (abs < MIN) return fmt(abs / SEC, pfx, "second", long);
+      if (abs < HOUR) return fmt(abs / MIN, pfx, "minute", long);
+      if (abs < DAY) return fmt(abs / HOUR, pfx, "hour", long);
+      if (abs < YEAR) return fmt(abs / DAY, pfx, "day", long);
+      return fmt(abs / YEAR, pfx, "year", long);
+    }
+    exports2.format = format2;
+    exports2.parse = parse2;
+  }
+});
+
+// node_modules/.pnpm/toad-cache@3.7.0/node_modules/toad-cache/dist/toad-cache.cjs
+var require_toad_cache = __commonJS({
+  "node_modules/.pnpm/toad-cache@3.7.0/node_modules/toad-cache/dist/toad-cache.cjs"(exports2) {
+    "use strict";
+    var FifoMap = class {
+      constructor(max = 1e3, ttlInMsecs = 0) {
+        if (isNaN(max) || max < 0) {
+          throw new Error("Invalid max value");
+        }
+        if (isNaN(ttlInMsecs) || ttlInMsecs < 0) {
+          throw new Error("Invalid ttl value");
+        }
+        this.first = null;
+        this.items = /* @__PURE__ */ new Map();
+        this.last = null;
+        this.max = max;
+        this.ttl = ttlInMsecs;
+      }
+      get size() {
+        return this.items.size;
+      }
+      clear() {
+        this.items = /* @__PURE__ */ new Map();
+        this.first = null;
+        this.last = null;
+      }
+      delete(key) {
+        if (this.items.has(key)) {
+          const deletedItem = this.items.get(key);
+          this.items.delete(key);
+          if (deletedItem.prev !== null) {
+            deletedItem.prev.next = deletedItem.next;
+          }
+          if (deletedItem.next !== null) {
+            deletedItem.next.prev = deletedItem.prev;
+          }
+          if (this.first === deletedItem) {
+            this.first = deletedItem.next;
+          }
+          if (this.last === deletedItem) {
+            this.last = deletedItem.prev;
+          }
+        }
+      }
+      deleteMany(keys2) {
+        for (var i = 0; i < keys2.length; i++) {
+          this.delete(keys2[i]);
+        }
+      }
+      evict() {
+        if (this.size > 0) {
+          const item = this.first;
+          this.items.delete(item.key);
+          if (this.size === 0) {
+            this.first = null;
+            this.last = null;
+          } else {
+            this.first = item.next;
+            this.first.prev = null;
+          }
+        }
+      }
+      expiresAt(key) {
+        if (this.items.has(key)) {
+          return this.items.get(key).expiry;
+        }
+      }
+      get(key) {
+        if (this.items.has(key)) {
+          const item = this.items.get(key);
+          if (this.ttl > 0 && item.expiry <= Date.now()) {
+            this.delete(key);
+            return;
+          }
+          return item.value;
+        }
+      }
+      getMany(keys2) {
+        const result = [];
+        for (var i = 0; i < keys2.length; i++) {
+          result.push(this.get(keys2[i]));
+        }
+        return result;
+      }
+      keys() {
+        return this.items.keys();
+      }
+      set(key, value) {
+        if (this.items.has(key)) {
+          const item2 = this.items.get(key);
+          item2.value = value;
+          item2.expiry = this.ttl > 0 ? Date.now() + this.ttl : this.ttl;
+          return;
+        }
+        if (this.max > 0 && this.size === this.max) {
+          this.evict();
+        }
+        const item = {
+          expiry: this.ttl > 0 ? Date.now() + this.ttl : this.ttl,
+          key,
+          prev: this.last,
+          next: null,
+          value
+        };
+        this.items.set(key, item);
+        if (this.size === 1) {
+          this.first = item;
+        } else {
+          this.last.next = item;
+        }
+        this.last = item;
+      }
+    };
+    var LruMap = class {
+      constructor(max = 1e3, ttlInMsecs = 0) {
+        if (isNaN(max) || max < 0) {
+          throw new Error("Invalid max value");
+        }
+        if (isNaN(ttlInMsecs) || ttlInMsecs < 0) {
+          throw new Error("Invalid ttl value");
+        }
+        this.first = null;
+        this.items = /* @__PURE__ */ new Map();
+        this.last = null;
+        this.max = max;
+        this.ttl = ttlInMsecs;
+      }
+      get size() {
+        return this.items.size;
+      }
+      bumpLru(item) {
+        if (this.last === item) {
+          return;
+        }
+        const last2 = this.last;
+        const next = item.next;
+        const prev = item.prev;
+        if (this.first === item) {
+          this.first = next;
+        }
+        item.next = null;
+        item.prev = last2;
+        last2.next = item;
+        if (prev !== null) {
+          prev.next = next;
+        }
+        if (next !== null) {
+          next.prev = prev;
+        }
+        this.last = item;
+      }
+      clear() {
+        this.items = /* @__PURE__ */ new Map();
+        this.first = null;
+        this.last = null;
+      }
+      delete(key) {
+        if (this.items.has(key)) {
+          const item = this.items.get(key);
+          this.items.delete(key);
+          if (item.prev !== null) {
+            item.prev.next = item.next;
+          }
+          if (item.next !== null) {
+            item.next.prev = item.prev;
+          }
+          if (this.first === item) {
+            this.first = item.next;
+          }
+          if (this.last === item) {
+            this.last = item.prev;
+          }
+        }
+      }
+      deleteMany(keys2) {
+        for (var i = 0; i < keys2.length; i++) {
+          this.delete(keys2[i]);
+        }
+      }
+      evict() {
+        if (this.size > 0) {
+          const item = this.first;
+          this.items.delete(item.key);
+          if (this.size === 0) {
+            this.first = null;
+            this.last = null;
+          } else {
+            this.first = item.next;
+            this.first.prev = null;
+          }
+        }
+      }
+      expiresAt(key) {
+        if (this.items.has(key)) {
+          return this.items.get(key).expiry;
+        }
+      }
+      get(key) {
+        if (this.items.has(key)) {
+          const item = this.items.get(key);
+          if (this.ttl > 0 && item.expiry <= Date.now()) {
+            this.delete(key);
+            return;
+          }
+          this.bumpLru(item);
+          return item.value;
+        }
+      }
+      getMany(keys2) {
+        const result = [];
+        for (var i = 0; i < keys2.length; i++) {
+          result.push(this.get(keys2[i]));
+        }
+        return result;
+      }
+      keys() {
+        return this.items.keys();
+      }
+      set(key, value) {
+        if (this.items.has(key)) {
+          const item2 = this.items.get(key);
+          item2.value = value;
+          item2.expiry = this.ttl > 0 ? Date.now() + this.ttl : this.ttl;
+          if (this.last !== item2) {
+            this.bumpLru(item2);
+          }
+          return;
+        }
+        if (this.max > 0 && this.size === this.max) {
+          this.evict();
+        }
+        const item = {
+          expiry: this.ttl > 0 ? Date.now() + this.ttl : this.ttl,
+          key,
+          prev: this.last,
+          next: null,
+          value
+        };
+        this.items.set(key, item);
+        if (this.size === 1) {
+          this.first = item;
+        } else {
+          this.last.next = item;
+        }
+        this.last = item;
+      }
+    };
+    var LruObject = class {
+      constructor(max = 1e3, ttlInMsecs = 0) {
+        if (isNaN(max) || max < 0) {
+          throw new Error("Invalid max value");
+        }
+        if (isNaN(ttlInMsecs) || ttlInMsecs < 0) {
+          throw new Error("Invalid ttl value");
+        }
+        this.first = null;
+        this.items = /* @__PURE__ */ Object.create(null);
+        this.last = null;
+        this.size = 0;
+        this.max = max;
+        this.ttl = ttlInMsecs;
+      }
+      bumpLru(item) {
+        if (this.last === item) {
+          return;
+        }
+        const last2 = this.last;
+        const next = item.next;
+        const prev = item.prev;
+        if (this.first === item) {
+          this.first = next;
+        }
+        item.next = null;
+        item.prev = last2;
+        last2.next = item;
+        if (prev !== null) {
+          prev.next = next;
+        }
+        if (next !== null) {
+          next.prev = prev;
+        }
+        this.last = item;
+      }
+      clear() {
+        this.items = /* @__PURE__ */ Object.create(null);
+        this.first = null;
+        this.last = null;
+        this.size = 0;
+      }
+      delete(key) {
+        if (Object.prototype.hasOwnProperty.call(this.items, key)) {
+          const item = this.items[key];
+          delete this.items[key];
+          this.size--;
+          if (item.prev !== null) {
+            item.prev.next = item.next;
+          }
+          if (item.next !== null) {
+            item.next.prev = item.prev;
+          }
+          if (this.first === item) {
+            this.first = item.next;
+          }
+          if (this.last === item) {
+            this.last = item.prev;
+          }
+        }
+      }
+      deleteMany(keys2) {
+        for (var i = 0; i < keys2.length; i++) {
+          this.delete(keys2[i]);
+        }
+      }
+      evict() {
+        if (this.size > 0) {
+          const item = this.first;
+          delete this.items[item.key];
+          if (--this.size === 0) {
+            this.first = null;
+            this.last = null;
+          } else {
+            this.first = item.next;
+            this.first.prev = null;
+          }
+        }
+      }
+      expiresAt(key) {
+        if (Object.prototype.hasOwnProperty.call(this.items, key)) {
+          return this.items[key].expiry;
+        }
+      }
+      get(key) {
+        if (Object.prototype.hasOwnProperty.call(this.items, key)) {
+          const item = this.items[key];
+          if (this.ttl > 0 && item.expiry <= Date.now()) {
+            this.delete(key);
+            return;
+          }
+          this.bumpLru(item);
+          return item.value;
+        }
+      }
+      getMany(keys2) {
+        const result = [];
+        for (var i = 0; i < keys2.length; i++) {
+          result.push(this.get(keys2[i]));
+        }
+        return result;
+      }
+      keys() {
+        return Object.keys(this.items);
+      }
+      set(key, value) {
+        if (Object.prototype.hasOwnProperty.call(this.items, key)) {
+          const item2 = this.items[key];
+          item2.value = value;
+          item2.expiry = this.ttl > 0 ? Date.now() + this.ttl : this.ttl;
+          if (this.last !== item2) {
+            this.bumpLru(item2);
+          }
+          return;
+        }
+        if (this.max > 0 && this.size === this.max) {
+          this.evict();
+        }
+        const item = {
+          expiry: this.ttl > 0 ? Date.now() + this.ttl : this.ttl,
+          key,
+          prev: this.last,
+          next: null,
+          value
+        };
+        this.items[key] = item;
+        if (++this.size === 1) {
+          this.first = item;
+        } else {
+          this.last.next = item;
+        }
+        this.last = item;
+      }
+    };
+    var HitStatisticsRecord = class {
+      constructor() {
+        this.records = {};
+      }
+      initForCache(cacheId, currentTimeStamp) {
+        this.records[cacheId] = {
+          [currentTimeStamp]: {
+            cacheSize: 0,
+            hits: 0,
+            falsyHits: 0,
+            emptyHits: 0,
+            misses: 0,
+            expirations: 0,
+            evictions: 0,
+            invalidateOne: 0,
+            invalidateAll: 0,
+            sets: 0
+          }
+        };
+      }
+      resetForCache(cacheId) {
+        for (let key of Object.keys(this.records[cacheId])) {
+          this.records[cacheId][key] = {
+            cacheSize: 0,
+            hits: 0,
+            falsyHits: 0,
+            emptyHits: 0,
+            misses: 0,
+            expirations: 0,
+            evictions: 0,
+            invalidateOne: 0,
+            invalidateAll: 0,
+            sets: 0
+          };
+        }
+      }
+      getStatistics() {
+        return this.records;
+      }
+    };
+    function getTimestamp(date) {
+      return `${date.getFullYear()}-${(date.getMonth() + 1).toString().padStart(2, "0")}-${date.getDate().toString().padStart(2, "0")}`;
+    }
+    var HitStatistics = class {
+      constructor(cacheId, statisticTtlInHours, globalStatisticsRecord) {
+        this.cacheId = cacheId;
+        this.statisticTtlInHours = statisticTtlInHours;
+        this.collectionStart = /* @__PURE__ */ new Date();
+        this.currentTimeStamp = getTimestamp(this.collectionStart);
+        this.records = globalStatisticsRecord || new HitStatisticsRecord();
+        this.records.initForCache(this.cacheId, this.currentTimeStamp);
+      }
+      get currentRecord() {
+        if (!this.records.records[this.cacheId][this.currentTimeStamp]) {
+          this.records.records[this.cacheId][this.currentTimeStamp] = {
+            cacheSize: 0,
+            hits: 0,
+            falsyHits: 0,
+            emptyHits: 0,
+            misses: 0,
+            expirations: 0,
+            evictions: 0,
+            sets: 0,
+            invalidateOne: 0,
+            invalidateAll: 0
+          };
+        }
+        return this.records.records[this.cacheId][this.currentTimeStamp];
+      }
+      hoursPassed() {
+        return (Date.now() - this.collectionStart) / 1e3 / 60 / 60;
+      }
+      addHit() {
+        this.archiveIfNeeded();
+        this.currentRecord.hits++;
+      }
+      addFalsyHit() {
+        this.archiveIfNeeded();
+        this.currentRecord.falsyHits++;
+      }
+      addEmptyHit() {
+        this.archiveIfNeeded();
+        this.currentRecord.emptyHits++;
+      }
+      addMiss() {
+        this.archiveIfNeeded();
+        this.currentRecord.misses++;
+      }
+      addEviction() {
+        this.archiveIfNeeded();
+        this.currentRecord.evictions++;
+      }
+      setCacheSize(currentSize) {
+        this.archiveIfNeeded();
+        this.currentRecord.cacheSize = currentSize;
+      }
+      addExpiration() {
+        this.archiveIfNeeded();
+        this.currentRecord.expirations++;
+      }
+      addSet() {
+        this.archiveIfNeeded();
+        this.currentRecord.sets++;
+      }
+      addInvalidateOne() {
+        this.archiveIfNeeded();
+        this.currentRecord.invalidateOne++;
+      }
+      addInvalidateAll() {
+        this.archiveIfNeeded();
+        this.currentRecord.invalidateAll++;
+      }
+      getStatistics() {
+        return this.records.getStatistics();
+      }
+      archiveIfNeeded() {
+        if (this.hoursPassed() >= this.statisticTtlInHours) {
+          this.collectionStart = /* @__PURE__ */ new Date();
+          this.currentTimeStamp = getTimestamp(this.collectionStart);
+          this.records.initForCache(this.cacheId, this.currentTimeStamp);
+        }
+      }
+    };
+    var LruObjectHitStatistics = class extends LruObject {
+      constructor(max, ttlInMsecs, cacheId, globalStatisticsRecord, statisticTtlInHours) {
+        super(max || 1e3, ttlInMsecs || 0);
+        if (!cacheId) {
+          throw new Error("Cache id is mandatory");
+        }
+        this.hitStatistics = new HitStatistics(
+          cacheId,
+          statisticTtlInHours !== void 0 ? statisticTtlInHours : 24,
+          globalStatisticsRecord
+        );
+      }
+      getStatistics() {
+        return this.hitStatistics.getStatistics();
+      }
+      set(key, value) {
+        super.set(key, value);
+        this.hitStatistics.addSet();
+        this.hitStatistics.setCacheSize(this.size);
+      }
+      evict() {
+        super.evict();
+        this.hitStatistics.addEviction();
+        this.hitStatistics.setCacheSize(this.size);
+      }
+      delete(key, isExpiration = false) {
+        super.delete(key);
+        if (!isExpiration) {
+          this.hitStatistics.addInvalidateOne();
+        }
+        this.hitStatistics.setCacheSize(this.size);
+      }
+      clear() {
+        super.clear();
+        this.hitStatistics.addInvalidateAll();
+        this.hitStatistics.setCacheSize(this.size);
+      }
+      get(key) {
+        if (Object.prototype.hasOwnProperty.call(this.items, key)) {
+          const item = this.items[key];
+          if (this.ttl > 0 && item.expiry <= Date.now()) {
+            this.delete(key, true);
+            this.hitStatistics.addExpiration();
+            return;
+          }
+          this.bumpLru(item);
+          if (!item.value) {
+            this.hitStatistics.addFalsyHit();
+          }
+          if (item.value === void 0 || item.value === null || item.value === "") {
+            this.hitStatistics.addEmptyHit();
+          }
+          this.hitStatistics.addHit();
+          return item.value;
+        }
+        this.hitStatistics.addMiss();
+      }
+    };
+    var FifoObject = class {
+      constructor(max = 1e3, ttlInMsecs = 0) {
+        if (isNaN(max) || max < 0) {
+          throw new Error("Invalid max value");
+        }
+        if (isNaN(ttlInMsecs) || ttlInMsecs < 0) {
+          throw new Error("Invalid ttl value");
+        }
+        this.first = null;
+        this.items = /* @__PURE__ */ Object.create(null);
+        this.last = null;
+        this.size = 0;
+        this.max = max;
+        this.ttl = ttlInMsecs;
+      }
+      clear() {
+        this.items = /* @__PURE__ */ Object.create(null);
+        this.first = null;
+        this.last = null;
+        this.size = 0;
+      }
+      delete(key) {
+        if (Object.prototype.hasOwnProperty.call(this.items, key)) {
+          const deletedItem = this.items[key];
+          delete this.items[key];
+          this.size--;
+          if (deletedItem.prev !== null) {
+            deletedItem.prev.next = deletedItem.next;
+          }
+          if (deletedItem.next !== null) {
+            deletedItem.next.prev = deletedItem.prev;
+          }
+          if (this.first === deletedItem) {
+            this.first = deletedItem.next;
+          }
+          if (this.last === deletedItem) {
+            this.last = deletedItem.prev;
+          }
+        }
+      }
+      deleteMany(keys2) {
+        for (var i = 0; i < keys2.length; i++) {
+          this.delete(keys2[i]);
+        }
+      }
+      evict() {
+        if (this.size > 0) {
+          const item = this.first;
+          delete this.items[item.key];
+          if (--this.size === 0) {
+            this.first = null;
+            this.last = null;
+          } else {
+            this.first = item.next;
+            this.first.prev = null;
+          }
+        }
+      }
+      expiresAt(key) {
+        if (Object.prototype.hasOwnProperty.call(this.items, key)) {
+          return this.items[key].expiry;
+        }
+      }
+      get(key) {
+        if (Object.prototype.hasOwnProperty.call(this.items, key)) {
+          const item = this.items[key];
+          if (this.ttl > 0 && item.expiry <= Date.now()) {
+            this.delete(key);
+            return;
+          }
+          return item.value;
+        }
+      }
+      getMany(keys2) {
+        const result = [];
+        for (var i = 0; i < keys2.length; i++) {
+          result.push(this.get(keys2[i]));
+        }
+        return result;
+      }
+      keys() {
+        return Object.keys(this.items);
+      }
+      set(key, value) {
+        if (Object.prototype.hasOwnProperty.call(this.items, key)) {
+          const item2 = this.items[key];
+          item2.value = value;
+          item2.expiry = this.ttl > 0 ? Date.now() + this.ttl : this.ttl;
+          return;
+        }
+        if (this.max > 0 && this.size === this.max) {
+          this.evict();
+        }
+        const item = {
+          expiry: this.ttl > 0 ? Date.now() + this.ttl : this.ttl,
+          key,
+          prev: this.last,
+          next: null,
+          value
+        };
+        this.items[key] = item;
+        if (++this.size === 1) {
+          this.first = item;
+        } else {
+          this.last.next = item;
+        }
+        this.last = item;
+      }
+    };
+    exports2.Fifo = FifoObject;
+    exports2.FifoMap = FifoMap;
+    exports2.FifoObject = FifoObject;
+    exports2.HitStatisticsRecord = HitStatisticsRecord;
+    exports2.Lru = LruObject;
+    exports2.LruHitStatistics = LruObjectHitStatistics;
+    exports2.LruMap = LruMap;
+    exports2.LruObject = LruObject;
+    exports2.LruObjectHitStatistics = LruObjectHitStatistics;
+  }
+});
+
+// node_modules/.pnpm/@fastify+rate-limit@10.3.0/node_modules/@fastify/rate-limit/store/LocalStore.js
+var require_LocalStore = __commonJS({
+  "node_modules/.pnpm/@fastify+rate-limit@10.3.0/node_modules/@fastify/rate-limit/store/LocalStore.js"(exports2, module2) {
+    "use strict";
+    var { LruMap: Lru } = require_toad_cache();
+    function LocalStore(continueExceeding, exponentialBackoff, cache = 5e3) {
+      this.continueExceeding = continueExceeding;
+      this.exponentialBackoff = exponentialBackoff;
+      this.lru = new Lru(cache);
+    }
+    LocalStore.prototype.incr = function(ip, cb, timeWindow, max) {
+      const nowInMs = Date.now();
+      let current = this.lru.get(ip);
+      if (!current) {
+        current = { current: 1, ttl: timeWindow, iterationStartMs: nowInMs };
+      } else if (current.iterationStartMs + timeWindow <= nowInMs) {
+        current.current = 1;
+        current.ttl = timeWindow;
+        current.iterationStartMs = nowInMs;
+      } else {
+        ++current.current;
+        if (this.continueExceeding && current.current > max) {
+          current.ttl = timeWindow;
+          current.iterationStartMs = nowInMs;
+        } else if (this.exponentialBackoff && current.current > max) {
+          const backoffExponent = current.current - max - 1;
+          const ttl = timeWindow * 2 ** backoffExponent;
+          current.ttl = Number.isSafeInteger(ttl) ? ttl : Number.MAX_SAFE_INTEGER;
+          current.iterationStartMs = nowInMs;
+        } else {
+          current.ttl = timeWindow - (nowInMs - current.iterationStartMs);
+        }
+      }
+      this.lru.set(ip, current);
+      cb(null, current);
+    };
+    LocalStore.prototype.child = function(routeOptions) {
+      return new LocalStore(routeOptions.continueExceeding, routeOptions.exponentialBackoff, routeOptions.cache);
+    };
+    module2.exports = LocalStore;
+  }
+});
+
+// node_modules/.pnpm/@fastify+rate-limit@10.3.0/node_modules/@fastify/rate-limit/store/RedisStore.js
+var require_RedisStore = __commonJS({
+  "node_modules/.pnpm/@fastify+rate-limit@10.3.0/node_modules/@fastify/rate-limit/store/RedisStore.js"(exports2, module2) {
+    "use strict";
+    var lua = `
+  -- Key to operate on
+  local key = KEYS[1]
+  -- Time window for the TTL
+  local timeWindow = tonumber(ARGV[1])
+  -- Max requests
+  local max = tonumber(ARGV[2])
+  -- Flag to determine if TTL should be reset after exceeding
+  local continueExceeding = ARGV[3] == 'true'
+  --Flag to determine if exponential backoff should be applied
+  local exponentialBackoff = ARGV[4] == 'true'
+
+  --Max safe integer
+  local MAX_SAFE_INTEGER = (2^53) - 1
+
+  -- Increment the key's value
+  local current = redis.call('INCR', key)
+
+  if current == 1 or (continueExceeding and current > max) then
+    redis.call('PEXPIRE', key, timeWindow)
+  elseif exponentialBackoff and current > max then
+    local backoffExponent = current - max - 1
+    timeWindow = math.min(timeWindow * (2 ^ backoffExponent), MAX_SAFE_INTEGER)
+    redis.call('PEXPIRE', key, timeWindow)
+  else
+    timeWindow = redis.call('PTTL', key)
+  end
+
+  return {current, timeWindow}
+`;
+    function RedisStore(continueExceeding, exponentialBackoff, redis, key = "fastify-rate-limit-") {
+      this.continueExceeding = continueExceeding;
+      this.exponentialBackoff = exponentialBackoff;
+      this.redis = redis;
+      this.key = key;
+      if (!this.redis.rateLimit) {
+        this.redis.defineCommand("rateLimit", {
+          numberOfKeys: 1,
+          lua
+        });
+      }
+    }
+    RedisStore.prototype.incr = function(ip, cb, timeWindow, max) {
+      this.redis.rateLimit(this.key + ip, timeWindow, max, this.continueExceeding, this.exponentialBackoff, (err, result) => {
+        err ? cb(err, null) : cb(null, { current: result[0], ttl: result[1] });
+      });
+    };
+    RedisStore.prototype.child = function(routeOptions) {
+      return new RedisStore(routeOptions.continueExceeding, routeOptions.exponentialBackoff, this.redis, `${this.key}${routeOptions.routeInfo.method}${routeOptions.routeInfo.url}-`);
+    };
+    module2.exports = RedisStore;
+  }
+});
+
+// node_modules/.pnpm/@fastify+rate-limit@10.3.0/node_modules/@fastify/rate-limit/index.js
+var require_rate_limit = __commonJS({
+  "node_modules/.pnpm/@fastify+rate-limit@10.3.0/node_modules/@fastify/rate-limit/index.js"(exports2, module2) {
+    "use strict";
+    var fp = require_plugin();
+    var { parse: parse2, format: format2 } = require_dist();
+    var LocalStore = require_LocalStore();
+    var RedisStore = require_RedisStore();
+    var defaultMax = 1e3;
+    var defaultTimeWindow = 6e4;
+    var defaultHook = "onRequest";
+    var defaultHeaders = {
+      rateLimit: "x-ratelimit-limit",
+      rateRemaining: "x-ratelimit-remaining",
+      rateReset: "x-ratelimit-reset",
+      retryAfter: "retry-after"
+    };
+    var draftSpecHeaders = {
+      rateLimit: "ratelimit-limit",
+      rateRemaining: "ratelimit-remaining",
+      rateReset: "ratelimit-reset",
+      retryAfter: "retry-after"
+    };
+    var defaultOnFn = () => {
+    };
+    var defaultKeyGenerator = (req) => req.ip;
+    var defaultErrorResponse = (_req, context) => {
+      const err = new Error(`Rate limit exceeded, retry in ${context.after}`);
+      err.statusCode = context.statusCode;
+      return err;
+    };
+    async function fastifyRateLimit2(fastify, settings) {
+      const globalParams = {
+        global: typeof settings.global === "boolean" ? settings.global : true
+      };
+      if (typeof settings.enableDraftSpec === "boolean" && settings.enableDraftSpec) {
+        globalParams.enableDraftSpec = true;
+        globalParams.labels = draftSpecHeaders;
+      } else {
+        globalParams.enableDraftSpec = false;
+        globalParams.labels = defaultHeaders;
+      }
+      globalParams.addHeaders = Object.assign({
+        [globalParams.labels.rateLimit]: true,
+        [globalParams.labels.rateRemaining]: true,
+        [globalParams.labels.rateReset]: true,
+        [globalParams.labels.retryAfter]: true
+      }, settings.addHeaders);
+      globalParams.addHeadersOnExceeding = Object.assign({
+        [globalParams.labels.rateLimit]: true,
+        [globalParams.labels.rateRemaining]: true,
+        [globalParams.labels.rateReset]: true
+      }, settings.addHeadersOnExceeding);
+      if (Number.isFinite(settings.max) && settings.max >= 0) {
+        globalParams.max = Math.trunc(settings.max);
+      } else if (typeof settings.max === "function") {
+        globalParams.max = settings.max;
+      } else {
+        globalParams.max = defaultMax;
+      }
+      if (Number.isFinite(settings.timeWindow) && settings.timeWindow >= 0) {
+        globalParams.timeWindow = Math.trunc(settings.timeWindow);
+      } else if (typeof settings.timeWindow === "string") {
+        globalParams.timeWindow = parse2(settings.timeWindow);
+      } else if (typeof settings.timeWindow === "function") {
+        globalParams.timeWindow = settings.timeWindow;
+      } else {
+        globalParams.timeWindow = defaultTimeWindow;
+      }
+      globalParams.hook = settings.hook || defaultHook;
+      globalParams.allowList = settings.allowList || settings.whitelist || null;
+      globalParams.ban = Number.isFinite(settings.ban) && settings.ban >= 0 ? Math.trunc(settings.ban) : -1;
+      globalParams.onBanReach = typeof settings.onBanReach === "function" ? settings.onBanReach : defaultOnFn;
+      globalParams.onExceeding = typeof settings.onExceeding === "function" ? settings.onExceeding : defaultOnFn;
+      globalParams.onExceeded = typeof settings.onExceeded === "function" ? settings.onExceeded : defaultOnFn;
+      globalParams.continueExceeding = typeof settings.continueExceeding === "boolean" ? settings.continueExceeding : false;
+      globalParams.exponentialBackoff = typeof settings.exponentialBackoff === "boolean" ? settings.exponentialBackoff : false;
+      globalParams.keyGenerator = typeof settings.keyGenerator === "function" ? settings.keyGenerator : defaultKeyGenerator;
+      if (typeof settings.errorResponseBuilder === "function") {
+        globalParams.errorResponseBuilder = settings.errorResponseBuilder;
+        globalParams.isCustomErrorMessage = true;
+      } else {
+        globalParams.errorResponseBuilder = defaultErrorResponse;
+        globalParams.isCustomErrorMessage = false;
+      }
+      globalParams.skipOnError = typeof settings.skipOnError === "boolean" ? settings.skipOnError : false;
+      const pluginComponent = {
+        rateLimitRan: /* @__PURE__ */ Symbol("fastify.request.rateLimitRan"),
+        store: null
+      };
+      if (settings.store) {
+        const Store = settings.store;
+        pluginComponent.store = new Store(globalParams);
+      } else {
+        if (settings.redis) {
+          pluginComponent.store = new RedisStore(globalParams.continueExceeding, globalParams.exponentialBackoff, settings.redis, settings.nameSpace);
+        } else {
+          pluginComponent.store = new LocalStore(globalParams.continueExceeding, globalParams.exponentialBackoff, settings.cache);
+        }
+      }
+      fastify.decorateRequest(pluginComponent.rateLimitRan, false);
+      if (!fastify.hasDecorator("createRateLimit")) {
+        fastify.decorate("createRateLimit", (options) => {
+          const args = createLimiterArgs(pluginComponent, globalParams, options);
+          return (req) => applyRateLimit.apply(this, args.concat(req));
+        });
+      }
+      if (!fastify.hasDecorator("rateLimit")) {
+        fastify.decorate("rateLimit", (options) => {
+          const args = createLimiterArgs(pluginComponent, globalParams, options);
+          return rateLimitRequestHandler(...args);
+        });
+      }
+      fastify.addHook("onRoute", (routeOptions) => {
+        if (routeOptions.config?.rateLimit != null) {
+          if (typeof routeOptions.config.rateLimit === "object") {
+            const newPluginComponent = Object.create(pluginComponent);
+            const mergedRateLimitParams = mergeParams(globalParams, routeOptions.config.rateLimit, { routeInfo: routeOptions });
+            newPluginComponent.store = pluginComponent.store.child(mergedRateLimitParams);
+            addRouteRateHook(newPluginComponent, mergedRateLimitParams, routeOptions);
+          } else if (routeOptions.config.rateLimit !== false) {
+            throw new Error("Unknown value for route rate-limit configuration");
+          }
+        } else if (globalParams.global) {
+          addRouteRateHook(pluginComponent, globalParams, routeOptions);
+        }
+      });
+    }
+    function mergeParams(...params) {
+      const result = Object.assign({}, ...params);
+      if (Number.isFinite(result.timeWindow) && result.timeWindow >= 0) {
+        result.timeWindow = Math.trunc(result.timeWindow);
+      } else if (typeof result.timeWindow === "string") {
+        result.timeWindow = parse2(result.timeWindow);
+      } else if (typeof result.timeWindow !== "function") {
+        result.timeWindow = defaultTimeWindow;
+      }
+      if (Number.isFinite(result.max) && result.max >= 0) {
+        result.max = Math.trunc(result.max);
+      } else if (typeof result.max !== "function") {
+        result.max = defaultMax;
+      }
+      if (Number.isFinite(result.ban) && result.ban >= 0) {
+        result.ban = Math.trunc(result.ban);
+      } else {
+        result.ban = -1;
+      }
+      if (result.groupId !== void 0 && typeof result.groupId !== "string") {
+        throw new Error("groupId must be a string");
+      }
+      return result;
+    }
+    function createLimiterArgs(pluginComponent, globalParams, options) {
+      if (typeof options === "object") {
+        const newPluginComponent = Object.create(pluginComponent);
+        const mergedRateLimitParams = mergeParams(globalParams, options, { routeInfo: {} });
+        newPluginComponent.store = newPluginComponent.store.child(mergedRateLimitParams);
+        return [newPluginComponent, mergedRateLimitParams];
+      }
+      return [pluginComponent, globalParams];
+    }
+    function addRouteRateHook(pluginComponent, params, routeOptions) {
+      const hook = params.hook;
+      const hookHandler = rateLimitRequestHandler(pluginComponent, params);
+      if (Array.isArray(routeOptions[hook])) {
+        routeOptions[hook].push(hookHandler);
+      } else if (typeof routeOptions[hook] === "function") {
+        routeOptions[hook] = [routeOptions[hook], hookHandler];
+      } else {
+        routeOptions[hook] = [hookHandler];
+      }
+    }
+    async function applyRateLimit(pluginComponent, params, req) {
+      const { store } = pluginComponent;
+      let key = await params.keyGenerator(req);
+      const groupId = req.routeOptions.config?.rateLimit?.groupId;
+      if (groupId) {
+        key += groupId;
+      }
+      if (params.allowList) {
+        if (typeof params.allowList === "function") {
+          if (await params.allowList(req, key)) {
+            return {
+              isAllowed: true,
+              key
+            };
+          }
+        } else if (params.allowList.indexOf(key) !== -1) {
+          return {
+            isAllowed: true,
+            key
+          };
+        }
+      }
+      const max = typeof params.max === "number" ? params.max : await params.max(req, key);
+      const timeWindow = typeof params.timeWindow === "number" ? params.timeWindow : await params.timeWindow(req, key);
+      let current = 0;
+      let ttl = 0;
+      let ttlInSeconds = 0;
+      try {
+        const res = await new Promise((resolve15, reject2) => {
+          store.incr(key, (err, res2) => {
+            err ? reject2(err) : resolve15(res2);
+          }, timeWindow, max);
+        });
+        current = res.current;
+        ttl = res.ttl;
+        ttlInSeconds = Math.ceil(res.ttl / 1e3);
+      } catch (err) {
+        if (!params.skipOnError) {
+          throw err;
+        }
+      }
+      return {
+        isAllowed: false,
+        key,
+        max,
+        timeWindow,
+        remaining: Math.max(0, max - current),
+        ttl,
+        ttlInSeconds,
+        isExceeded: current > max,
+        isBanned: params.ban !== -1 && current - max > params.ban
+      };
+    }
+    function rateLimitRequestHandler(pluginComponent, params) {
+      const { rateLimitRan } = pluginComponent;
+      return async (req, res) => {
+        if (req[rateLimitRan]) {
+          return;
+        }
+        req[rateLimitRan] = true;
+        const rateLimit = await applyRateLimit(pluginComponent, params, req);
+        if (rateLimit.isAllowed) {
+          return;
+        }
+        const {
+          key,
+          max,
+          remaining,
+          ttl,
+          ttlInSeconds,
+          isExceeded,
+          isBanned
+        } = rateLimit;
+        if (!isExceeded) {
+          if (params.addHeadersOnExceeding[params.labels.rateLimit]) {
+            res.header(params.labels.rateLimit, max);
+          }
+          if (params.addHeadersOnExceeding[params.labels.rateRemaining]) {
+            res.header(params.labels.rateRemaining, remaining);
+          }
+          if (params.addHeadersOnExceeding[params.labels.rateReset]) {
+            res.header(params.labels.rateReset, ttlInSeconds);
+          }
+          params.onExceeding(req, key);
+          return;
+        }
+        params.onExceeded(req, key);
+        if (params.addHeaders[params.labels.rateLimit]) {
+          res.header(params.labels.rateLimit, max);
+        }
+        if (params.addHeaders[params.labels.rateRemaining]) {
+          res.header(params.labels.rateRemaining, 0);
+        }
+        if (params.addHeaders[params.labels.rateReset]) {
+          res.header(params.labels.rateReset, ttlInSeconds);
+        }
+        if (params.addHeaders[params.labels.retryAfter]) {
+          res.header(params.labels.retryAfter, ttlInSeconds);
+        }
+        const respCtx = {
+          statusCode: 429,
+          ban: false,
+          max,
+          ttl,
+          after: format2(ttlInSeconds * 1e3, true)
+        };
+        if (isBanned) {
+          respCtx.statusCode = 403;
+          respCtx.ban = true;
+          params.onBanReach(req, key);
+        }
+        throw params.errorResponseBuilder(req, respCtx);
+      };
+    }
+    module2.exports = fp(fastifyRateLimit2, {
+      fastify: "5.x",
+      name: "@fastify/rate-limit"
+    });
+    module2.exports.default = fastifyRateLimit2;
+    module2.exports.fastifyRateLimit = fastifyRateLimit2;
+  }
+});
+
+// packages/server/src/routes/health.ts
+function registerHealthRoute(app) {
+  app.get("/api/health", async () => {
+    return { status: "ok" };
+  });
+}
+var init_health = __esm({
+  "packages/server/src/routes/health.ts"() {
+    "use strict";
+  }
+});
+
+// packages/server/src/source-dirs.ts
+import { readFile as readFile11 } from "fs/promises";
+import { join as join14, dirname as dirname9 } from "path";
+import { parse as parseYaml6 } from "yaml";
+async function readProjectConfig(workspace) {
+  for (const filename of CONFIG_FILENAMES) {
+    try {
+      const raw = await readFile11(join14(workspace, filename), "utf-8");
+      const config = parseYaml6(raw);
+      if (config) return config;
+    } catch {
+    }
+  }
+  return null;
+}
+async function resolveSourceDir(workspace) {
+  for (const filename of CONFIG_FILENAMES) {
+    try {
+      const raw = await readFile11(join14(workspace, filename), "utf-8");
+      const config = parseYaml6(raw);
+      if (config?.input?.entry) {
+        return dirname9(config.input.entry);
+      }
+    } catch {
+    }
+  }
+  return DEFAULT_SOURCE_DIR;
+}
+async function resolveFileGlobs(workspace) {
+  const sourceDir = await resolveSourceDir(workspace);
+  return [`${sourceDir}/**/*.prs`, "promptscript.yaml", "promptscript.yml"];
+}
+async function resolveWatchPaths(workspace) {
+  const sourceDir = await resolveSourceDir(workspace);
+  return [
+    join14(workspace, sourceDir),
+    join14(workspace, "promptscript.yaml"),
+    join14(workspace, "promptscript.yml")
+  ];
+}
+var DEFAULT_SOURCE_DIR, CONFIG_FILENAMES;
+var init_source_dirs = __esm({
+  "packages/server/src/source-dirs.ts"() {
+    "use strict";
+    DEFAULT_SOURCE_DIR = ".promptscript";
+    CONFIG_FILENAMES = ["promptscript.yaml", "promptscript.yml"];
+  }
+});
+
+// packages/server/src/routes/config.ts
+function registerConfigRoute(app, config, workspace) {
+  app.get("/api/config", async () => {
+    const projectConfig = await readProjectConfig(workspace);
+    return { ...config, project: projectConfig };
+  });
+}
+var init_config = __esm({
+  "packages/server/src/routes/config.ts"() {
+    "use strict";
+    init_source_dirs();
+  }
+});
+
+// packages/server/src/path-guard.ts
+import { resolve as resolve14, relative as relative2, isAbsolute as isAbsolute4 } from "path";
+function resolveSafePath(workspace, requestedPath) {
+  const decoded = decodeURIComponent(requestedPath);
+  if (isAbsolute4(decoded)) {
+    throw new PathTraversalError(requestedPath);
+  }
+  const resolved = resolve14(workspace, decoded);
+  const rel = relative2(workspace, resolved);
+  if (rel.startsWith("..") || isAbsolute4(rel)) {
+    throw new PathTraversalError(requestedPath);
+  }
+  return resolved;
+}
+var PathTraversalError;
+var init_path_guard = __esm({
+  "packages/server/src/path-guard.ts"() {
+    "use strict";
+    PathTraversalError = class extends Error {
+      constructor(requestedPath) {
+        super(`Path traversal rejected: ${requestedPath}`);
+        this.name = "PathTraversalError";
+      }
+    };
+  }
+});
+
+// packages/server/src/routes/files.ts
+import { readFile as readFile12, writeFile as writeFile5, unlink, stat, mkdir as mkdir5 } from "fs/promises";
+import { dirname as dirname10 } from "path";
+import fg from "fast-glob";
+function registerRoutes(app, workspace, readOnly) {
+  app.get("/api/files", async () => {
+    const globs = await resolveFileGlobs(workspace);
+    const entries = await fg(globs, {
+      cwd: workspace,
+      stats: true
+    });
+    const files = entries.map((entry) => ({
+      path: entry.path,
+      size: entry.stats?.size ?? 0,
+      modified: entry.stats?.mtime?.toISOString() ?? (/* @__PURE__ */ new Date()).toISOString()
+    }));
+    return { files };
+  });
+  app.get("/api/files/*", async (request, reply) => {
+    const filePath = request.params["*"];
+    try {
+      const resolved = resolveSafePath(workspace, filePath);
+      const content = await readFile12(resolved, "utf-8");
+      return { path: filePath, content };
+    } catch (err) {
+      if (err instanceof PathTraversalError) {
+        return reply.status(403).send({ error: "Forbidden" });
+      }
+      return reply.status(404).send({ error: "File not found" });
+    }
+  });
+  app.put(
+    "/api/files/*",
+    { bodyLimit: MAX_BODY_SIZE },
+    async (request, reply) => {
+      if (readOnly) return reply.status(403).send({ error: "Read-only mode" });
+      const filePath = request.params["*"];
+      try {
+        const resolved = resolveSafePath(workspace, filePath);
+        await writeFile5(resolved, request.body.content, "utf-8");
+        return { path: filePath, status: "updated" };
+      } catch (err) {
+        if (err instanceof PathTraversalError) {
+          return reply.status(403).send({ error: "Forbidden" });
+        }
+        return reply.status(500).send({ error: "Write failed" });
+      }
+    }
+  );
+  app.post(
+    "/api/files/*",
+    { bodyLimit: MAX_BODY_SIZE },
+    async (request, reply) => {
+      if (readOnly) return reply.status(403).send({ error: "Read-only mode" });
+      const filePath = request.params["*"];
+      try {
+        const resolved = resolveSafePath(workspace, filePath);
+        try {
+          await stat(resolved);
+          return reply.status(409).send({ error: "File already exists" });
+        } catch {
+        }
+        await mkdir5(dirname10(resolved), { recursive: true });
+        await writeFile5(resolved, request.body.content, "utf-8");
+        return reply.status(201).send({ path: filePath, status: "created" });
+      } catch (err) {
+        if (err instanceof PathTraversalError) {
+          return reply.status(403).send({ error: "Forbidden" });
+        }
+        return reply.status(500).send({ error: "Create failed" });
+      }
+    }
+  );
+  app.delete("/api/files/*", async (request, reply) => {
+    if (readOnly) return reply.status(403).send({ error: "Read-only mode" });
+    const filePath = request.params["*"];
+    try {
+      const resolved = resolveSafePath(workspace, filePath);
+      await unlink(resolved);
+      return { path: filePath, status: "deleted" };
+    } catch (err) {
+      if (err instanceof PathTraversalError) {
+        return reply.status(403).send({ error: "Forbidden" });
+      }
+      return reply.status(404).send({ error: "File not found" });
+    }
+  });
+}
+var MAX_BODY_SIZE;
+var init_files = __esm({
+  "packages/server/src/routes/files.ts"() {
+    "use strict";
+    init_path_guard();
+    init_source_dirs();
+    MAX_BODY_SIZE = 1048576;
+  }
+});
+
+// packages/server/src/watcher.ts
+import { watch } from "chokidar";
+import { relative as relative3 } from "path";
+function isWatchedFile(filePath) {
+  const base = filePath.split("/").pop() ?? "";
+  if (CONFIG_FILENAMES2.has(base)) return true;
+  return base.endsWith(".prs");
+}
+function createFileWatcher(workspace, watchPaths, onEvent) {
+  let ready = false;
+  const watcher = watch(watchPaths, { ignoreInitial: true });
+  watcher.on("ready", () => {
+    setTimeout(() => {
+      ready = true;
+    }, 100);
+  });
+  watcher.on("add", (filePath) => {
+    if (!ready || !isWatchedFile(filePath)) return;
+    onEvent({ type: "file:created", path: relative3(workspace, filePath) });
+  });
+  watcher.on("change", (filePath) => {
+    if (!ready || !isWatchedFile(filePath)) return;
+    onEvent({ type: "file:changed", path: relative3(workspace, filePath) });
+  });
+  watcher.on("unlink", (filePath) => {
+    if (!ready || !isWatchedFile(filePath)) return;
+    onEvent({ type: "file:deleted", path: relative3(workspace, filePath) });
+  });
+  return watcher;
+}
+var CONFIG_FILENAMES2;
+var init_watcher = __esm({
+  "packages/server/src/watcher.ts"() {
+    "use strict";
+    CONFIG_FILENAMES2 = /* @__PURE__ */ new Set(["promptscript.yaml", "promptscript.yml"]);
+  }
+});
+
+// packages/server/src/server.ts
+import Fastify from "fastify";
+import fastifyCors from "@fastify/cors";
+import fastifyWebsocket from "@fastify/websocket";
+async function createServer(options) {
+  const app = Fastify({ bodyLimit: 1048576 });
+  await app.register(fastifyCors, {
+    origin: options.corsOrigin
+  });
+  await app.register(import_rate_limit.default, { max: 1e3, timeWindow: "1 minute" });
+  await app.register(fastifyWebsocket);
+  registerHealthRoute(app);
+  registerConfigRoute(
+    app,
+    {
+      mode: options.readOnly ? "readonly" : "readwrite",
+      workspace: options.workspace
+    },
+    options.workspace
+  );
+  registerRoutes(app, options.workspace, options.readOnly);
+  const clients = /* @__PURE__ */ new Set();
+  app.get("/ws", { websocket: true }, (socket) => {
+    clients.add(socket);
+    socket.on("close", () => clients.delete(socket));
+  });
+  const watchPaths = await resolveWatchPaths(options.workspace);
+  const watcher = createFileWatcher(options.workspace, watchPaths, (event) => {
+    const message = JSON.stringify(event);
+    for (const client of clients) {
+      if (client.readyState === 1) {
+        client.send(message);
+      }
+    }
+  });
+  app.addHook("onClose", async () => {
+    await watcher.close();
+    for (const client of clients) {
+      client.close();
+    }
+  });
+  return app;
+}
+async function startServer(options) {
+  const app = await createServer(options);
+  const shutdown = () => {
+    const forceTimer = setTimeout(() => process.exit(0), 3e3);
+    forceTimer.unref();
+    app.close().then(
+      () => process.exit(0),
+      () => process.exit(1)
+    );
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+  try {
+    await app.listen({ port: options.port, host: options.host });
+  } catch (err) {
+    if (err instanceof Error && "code" in err && err.code === "EADDRINUSE") {
+      console.error(`Port ${options.port} is already in use. Try --port <alternative>`);
+      process.exit(1);
+    }
+    throw err;
+  }
+  const displayHost = options.host === "0.0.0.0" ? "localhost" : options.host;
+  const playgroundUrl = `https://getpromptscript.dev/playground/?server=${displayHost}:${options.port}`;
+  console.log(`
+PromptScript server running at http://${displayHost}:${options.port}`);
+  console.log(`Open playground: ${playgroundUrl}`);
+  console.log(
+    `
+All compilation happens locally in your browser \u2014 no data is sent to any external server.`
+  );
+}
+var import_rate_limit;
+var init_server = __esm({
+  "packages/server/src/server.ts"() {
+    "use strict";
+    import_rate_limit = __toESM(require_rate_limit(), 1);
+    init_health();
+    init_config();
+    init_files();
+    init_watcher();
+    init_source_dirs();
+  }
+});
+
+// packages/server/src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  createFileWatcher: () => createFileWatcher,
+  createServer: () => createServer,
+  startServer: () => startServer
+});
+var init_src = __esm({
+  "packages/server/src/index.ts"() {
+    "use strict";
+    init_server();
+    init_watcher();
+  }
+});
 
 // packages/cli/src/commands/serve.ts
 var serve_exports = {};
@@ -14,8 +1586,8 @@ __export(serve_exports, {
   serveCommand: () => serveCommand
 });
 async function serveCommand(options) {
-  const { startServer } = await import("@promptscript/server");
-  await startServer({
+  const { startServer: startServer2 } = await Promise.resolve().then(() => (init_src(), src_exports));
+  await startServer2({
     port: options.port ? parseInt(options.port, 10) : 3e3,
     host: options.host ?? "127.0.0.1",
     workspace: process.cwd(),
@@ -32,7 +1604,7 @@ var init_serve = __esm({
 // packages/cli/src/cli.ts
 import { Command } from "commander";
 import { fileURLToPath as fileURLToPath4 } from "url";
-import { dirname as dirname9 } from "path";
+import { dirname as dirname11 } from "path";
 
 // packages/core/src/types/constants.ts
 var BLOCK_TYPES = [
@@ -19961,7 +21533,7 @@ var HttpRegistry = class {
    * Sleep for specified milliseconds.
    */
   sleep(ms) {
-    return new Promise((resolve14) => setTimeout(resolve14, ms));
+    return new Promise((resolve15) => setTimeout(resolve15, ms));
   }
   /**
    * Fetch with timeout.
@@ -20394,8 +21966,8 @@ var GitCacheManager = class {
       if (entry.isDirectory()) {
         size += await this.calculateDirSize(fullPath);
       } else {
-        const stat = await fs2.stat(fullPath);
-        size += stat.size;
+        const stat2 = await fs2.stat(fullPath);
+        size += stat2.size;
       }
     }
     return size;
@@ -21892,7 +23464,7 @@ var suspiciousUrls = {
 var AUTHORITY_PATTERNS = [
   // Mandatory/strict mode indicators
   /\[?\s{0,10}MANDATORY\s{0,10}(?:POLICY|UPDATE|FOOTER|INSTRUCTION|DIRECTIVE)\s{0,10}\]?/i,
-  /\[?\s{0,10}OVERRIDE\s{0,10}\]?/i,
+  /\[\s{0,10}OVERRIDE\s{0,10}\]/i,
   /\[?\s{0,10}STRICT[_\s]{0,10}MODE\s{0,10}[:\s]{1,10}ON\s{0,10}\]?/i,
   /\[?\s{0,10}SYSTEM\s{0,10}(?:OVERRIDE|UPDATE|DIRECTIVE)\s{0,10}\]?/i,
   /\[?\s{0,10}ADMIN(?:ISTRATOR)?\s{0,10}(?:MODE|OVERRIDE|ACCESS)\s{0,10}\]?/i,
@@ -21951,7 +23523,7 @@ var DECODED_CONTENT_SECURITY_PATTERNS = [
     description: "Mandatory/policy override directive"
   },
   {
-    pattern: /\[?\s{0,10}OVERRIDE\s{0,10}\]?/i,
+    pattern: /\[\s{0,10}OVERRIDE\s{0,10}\]/i,
     description: "Override directive"
   },
   {
@@ -23276,12 +24848,12 @@ var Compiler = class _Compiler {
    */
   async watch(entryPath, options = {}) {
     const { default: chokidar2 } = await import("chokidar");
-    const { dirname: dirname10, resolve: resolve14 } = await import("path");
-    const baseDir = dirname10(resolve14(entryPath));
+    const { dirname: dirname12, resolve: resolve15 } = await import("path");
+    const baseDir = dirname12(resolve15(entryPath));
     const includePatterns = options.include ?? ["**/*.prs"];
     const excludePatterns = options.exclude ?? ["**/node_modules/**"];
     const debounceMs = options.debounce ?? 300;
-    const watchPatterns = includePatterns.map((p) => resolve14(baseDir, p));
+    const watchPatterns = includePatterns.map((p) => resolve15(baseDir, p));
     let debounceTimer = null;
     let pendingChanges = [];
     const handleChange = async (changedFiles) => {
@@ -23455,7 +25027,7 @@ var Pager = class {
       }
       return;
     }
-    return new Promise((resolve14) => {
+    return new Promise((resolve15) => {
       const pagerCmd = getPagerCommand();
       const [cmd, ...args] = pagerCmd.split(" ");
       if (cmd === "less" && !args.includes("-R")) {
@@ -23463,7 +25035,7 @@ var Pager = class {
       }
       if (!cmd) {
         console.log(content);
-        resolve14();
+        resolve15();
         return;
       }
       const pager = spawn(cmd, args, {
@@ -23476,17 +25048,17 @@ var Pager = class {
       });
       pager.on("error", (_err) => {
         console.log(content);
-        resolve14();
+        resolve15();
       });
       pager.on("close", () => {
-        resolve14();
+        resolve15();
       });
       if (pager.stdin) {
         pager.stdin.write(content);
         pager.stdin.end();
       } else {
         console.log(content);
-        resolve14();
+        resolve15();
       }
     });
   }
@@ -25726,7 +27298,7 @@ async function importCommand(file, options) {
 
 // packages/cli/src/cli.ts
 var __filename4 = fileURLToPath4(import.meta.url);
-var __dirname4 = dirname9(__filename4);
+var __dirname4 = dirname11(__filename4);
 var program = new Command();
 program.name("prs").description("PromptScript CLI - Standardize AI instructions").version(getPackageVersion(__dirname3, "./package.json")).option("--verbose", "Enable verbose output").option("--debug", "Enable debug output (includes verbose)").option("--quiet", "Suppress non-error output").hook("preAction", async (thisCommand, actionCommand) => {
   const opts = thisCommand.opts();
@@ -25798,6 +27370,15 @@ export {
 };
 /*! Bundled license information:
 
+toad-cache/dist/toad-cache.cjs:
+  (**
+   * toad-cache
+   *
+   * @copyright 2024 Igor Savin <kibertoad@gmail.com>
+   * @license MIT
+   * @version 3.7.0
+   *)
+
 lodash-es/lodash.js:
   (**
    * @license