@ps-generator-bridge/generator 0.1.0

package/dist/index.js

@@ -0,0 +1,2482 @@
+"use strict";
+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 __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : /* @__PURE__ */ Symbol.for("Symbol." + name);
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+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
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __decoratorStart = (base) => [, , , __create(base?.[__knownSymbol("metadata")] ?? null)];
+var __decoratorStrings = ["class", "method", "getter", "setter", "accessor", "field", "value", "get", "set"];
+var __expectFn = (fn) => fn !== void 0 && typeof fn !== "function" ? __typeError("Function expected") : fn;
+var __decoratorContext = (kind, name, done, metadata, fns) => ({ kind: __decoratorStrings[kind], name, metadata, addInitializer: (fn) => done._ ? __typeError("Already initialized") : fns.push(__expectFn(fn || null)) });
+var __decoratorMetadata = (array, target) => __defNormalProp(target, __knownSymbol("metadata"), array[3]);
+var __runInitializers = (array, flags, self, value) => {
+  for (var i = 0, fns = array[flags >> 1], n = fns && fns.length; i < n; i++) flags & 1 ? fns[i].call(self) : value = fns[i].call(self, value);
+  return value;
+};
+var __decorateElement = (array, flags, name, decorators, target, extra) => {
+  var fn, it, done, ctx, access, k = flags & 7, s = !!(flags & 8), p = !!(flags & 16);
+  var j = k > 3 ? array.length + 1 : k ? s ? 1 : 2 : 0, key = __decoratorStrings[k + 5];
+  var initializers = k > 3 && (array[j - 1] = []), extraInitializers = array[j] || (array[j] = []);
+  var desc = k && (!p && !s && (target = target.prototype), k < 5 && (k > 3 || !p) && __getOwnPropDesc(k < 4 ? target : { get [name]() {
+    return __privateGet(this, extra);
+  }, set [name](x) {
+    return __privateSet(this, extra, x);
+  } }, name));
+  k ? p && k < 4 && __name(extra, (k > 2 ? "set " : k > 1 ? "get " : "") + name) : __name(target, name);
+  for (var i = decorators.length - 1; i >= 0; i--) {
+    ctx = __decoratorContext(k, name, done = {}, array[3], extraInitializers);
+    if (k) {
+      ctx.static = s, ctx.private = p, access = ctx.access = { has: p ? (x) => __privateIn(target, x) : (x) => name in x };
+      if (k ^ 3) access.get = p ? (x) => (k ^ 1 ? __privateGet : __privateMethod)(x, target, k ^ 4 ? extra : desc.get) : (x) => x[name];
+      if (k > 2) access.set = p ? (x, y) => __privateSet(x, target, y, k ^ 4 ? extra : desc.set) : (x, y) => x[name] = y;
+    }
+    it = (0, decorators[i])(k ? k < 4 ? p ? extra : desc[key] : k > 4 ? void 0 : { get: desc.get, set: desc.set } : target, ctx), done._ = 1;
+    if (k ^ 4 || it === void 0) __expectFn(it) && (k > 4 ? initializers.unshift(it) : k ? p ? extra = it : desc[key] = it : target = it);
+    else if (typeof it !== "object" || it === null) __typeError("Object expected");
+    else __expectFn(fn = it.get) && (desc.get = fn), __expectFn(fn = it.set) && (desc.set = fn), __expectFn(fn = it.init) && initializers.unshift(fn);
+  }
+  return k || __decoratorMetadata(array, target), desc && __defProp(target, name, desc), p ? k ^ 4 ? extra : desc : target;
+};
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateIn = (member, obj) => Object(obj) !== obj ? __typeError('Cannot use the "in" operator on this value') : member.has(obj);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  JsxRunner: () => JsxRunner,
+  PsBridgeHost: () => PsBridgeHost,
+  init: () => init
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/plugin.ts
+var import_node_path4 = require("path");
+
+// src/server/index.ts
+var import_fastify = __toESM(require("fastify"));
+var import_websocket = __toESM(require("@fastify/websocket"));
+var import_node_crypto = require("crypto");
+
+// ../sdk/src/protocol.ts
+var ProtocolMethod = {
+  GetServerInfo: "getServerInfo",
+  JsxRun: "jsx:run",
+  JsxExecute: "jsx:execute",
+  EventSubscribe: "event:subscribe",
+  EventUnsubscribe: "event:unsubscribe",
+  ActionAutoCutout: "action:autoCutout",
+  ActionRemoveBackground: "action:removeBackground",
+  LayerGetInfo: "layer:getInfo",
+  LayerGetInfoById: "layer:getInfoById",
+  LayerGetInfoByIndex: "layer:getInfoByIndex",
+  DocumentCurrent: "document:current",
+  DocumentExport: "document:export",
+  DocumentSave: "document:save",
+  ImageExportLayer: "image:exportLayer",
+  ImageGetPreview: "image:getPreview",
+  ImageExportDocument: "image:exportDocument"
+};
+var ErrorCode = {
+  UnknownMethod: "UNKNOWN_METHOD",
+  BadRequest: "BAD_REQUEST",
+  Internal: "INTERNAL"
+};
+function isRequest(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const v = value;
+  return typeof v.id === "string" && typeof v.method === "string";
+}
+function parseFrame(data) {
+  return JSON.parse(data);
+}
+function serializeFrame(value) {
+  return JSON.stringify(value);
+}
+
+// ../sdk/src/photoshop/jsx-runner.ts
+function evalJson(jsx, expr) {
+  return jsx.run(`JSON.stringify(${expr})`).then((s) => JSON.parse(s));
+}
+function evalNumber(jsx, expr) {
+  return evalJson(jsx, `Number(${expr})`);
+}
+function evalString(jsx, expr) {
+  return evalJson(jsx, `String(${expr})`);
+}
+function evalBool(jsx, expr) {
+  return evalJson(jsx, `Boolean(${expr})`);
+}
+
+// ../sdk/src/photoshop/JsxBuilder.ts
+var JsxBuilder = class {
+  /**
+   * Escape a string into a JSX string literal. `JSON.stringify` handles quotes,
+   * newlines and Unicode.
+   *
+   * @example JsxBuilder.string("O'Brien") // -> "\"O'Brien\""
+   */
+  static string(value) {
+    return JSON.stringify(value);
+  }
+  /**
+   * Serialize a path to an ExtendScript `File` constructor.
+   *
+   * @example JsxBuilder.file("/path/to/file.psd") // -> 'new File("/path/to/file.psd")'
+   */
+  static file(path) {
+    return `new File(${JSON.stringify(path)})`;
+  }
+  /** Serialize a number, rejecting NaN/Infinity. */
+  static number(value) {
+    if (!isFinite(value)) {
+      throw new Error(`JsxBuilder.number: invalid value ${value}`);
+    }
+    return String(value);
+  }
+  /** Serialize a boolean. */
+  static boolean(value) {
+    return value ? "true" : "false";
+  }
+  /** Pass an enum string through (already in `EnumName.MEMBER` form). */
+  static enum_(value) {
+    return value;
+  }
+  /**
+   * Serialize a numeric array to a JSX array literal (bounds, crop, etc.).
+   *
+   * @example JsxBuilder.numberArray([0, 0, 100, 100]) // -> '[0,0,100,100]'
+   */
+  static numberArray(arr) {
+    return JSON.stringify(arr);
+  }
+  /** Serialize a 2-D numeric array (selection boundary points). */
+  static regionArray(region) {
+    return JSON.stringify(region);
+  }
+  /**
+   * Build a method-call expression from pre-serialized args.
+   *
+   * @example JsxBuilder.call("app.open", [JsxBuilder.file(path)])
+   *          // -> 'app.open(new File("/path/to/file.psd"))'
+   */
+  static call(path, args) {
+    return `${path}(${args.join(", ")})`;
+  }
+  /**
+   * Build a property assignment statement.
+   *
+   * @example JsxBuilder.assign("app.activeDocument.activeLayer.name", JsxBuilder.string("New Name"))
+   *          // -> 'app.activeDocument.activeLayer.name = "New Name"'
+   */
+  static assign(path, value) {
+    return `${path} = ${value}`;
+  }
+};
+
+// ../sdk/src/photoshop/PhotoshopLayer.ts
+var PhotoshopLayer = class _PhotoshopLayer {
+  constructor(_jsx, _path) {
+    this._jsx = _jsx;
+    this._path = _path;
+  }
+  // --- Layer read-only properties -----------------------------------------
+  /** Unique layer id. */
+  get id() {
+    return evalNumber(this._jsx, `${this._path}.id`);
+  }
+  /** Layer name. */
+  get name() {
+    return evalString(this._jsx, `${this._path}.name`);
+  }
+  /** Layer visibility. */
+  get visible() {
+    return evalBool(this._jsx, `${this._path}.visible`);
+  }
+  /** Layer opacity (0-100). */
+  get opacity() {
+    return evalNumber(this._jsx, `${this._path}.opacity`);
+  }
+  static {
+    /** BlendMode code -> enum-name map (all 27 members, plus newer ones). */
+    this._BLEND_MODE_MAP = {
+      1: "PASSTHROUGH",
+      2: "NORMAL",
+      3: "DISSOLVE",
+      4: "DARKEN",
+      5: "MULTIPLY",
+      6: "COLORBURN",
+      7: "LINEARBURN",
+      8: "LIGHTEN",
+      9: "SCREEN",
+      10: "COLORDODGE",
+      11: "LINEARDODGE",
+      12: "OVERLAY",
+      13: "SOFTLIGHT",
+      14: "HARDLIGHT",
+      15: "VIVIDLIGHT",
+      16: "LINEARLIGHT",
+      17: "PINLIGHT",
+      18: "DIFFERENCE",
+      19: "EXCLUSION",
+      20: "HUE",
+      21: "SATURATION",
+      22: "COLORBLEND",
+      23: "LUMINOSITY",
+      26: "HARDMIX",
+      27: "SUBTRACT",
+      28: "DARKERCOLOR",
+      29: "LIGHTERCOLOR",
+      30: "DIVIDE"
+    };
+  }
+  /**
+   * Blend mode as an enum-name string (e.g. "BlendMode.NORMAL"). ExtendScript
+   * yields the numeric code; the static map turns it into a readable name.
+   */
+  get blendMode() {
+    return evalNumber(this._jsx, `${this._path}.blendMode`).then(
+      (code) => _PhotoshopLayer._BLEND_MODE_MAP[code] ?? `BlendMode.UNKNOWN_${code}`
+    );
+  }
+  /** Whether the layer is fully locked. */
+  get allLocked() {
+    return evalBool(this._jsx, `${this._path}.allLocked`);
+  }
+  /**
+   * Layer bounds `[left, top, right, bottom]`.
+   *
+   * @remarks Units follow `rulerUnits`; values are not pixels unless it is
+   * `Units.PIXELS`.
+   */
+  get bounds() {
+    const expr = `(function(){ var b = ${this._path}.bounds; return [b[0], b[1], b[2], b[3]]; })()`;
+    return evalJson(this._jsx, expr);
+  }
+  static {
+    // --- ArtLayer-only properties -------------------------------------------
+    /** LayerKind code -> enum-name map. */
+    this._LAYER_KIND_MAP = {
+      1: "NORMAL",
+      2: "TEXT",
+      3: "SOLIDFILL",
+      4: "GRADIENTFILL",
+      5: "LEVELS",
+      6: "CURVES",
+      7: "COLORBALANCE",
+      8: "HUESATURATION",
+      9: "BRIGHTNESSCONTRAST",
+      10: "THRESHOLD",
+      11: "POSTERIZE",
+      12: "CHANNELMIXER",
+      13: "GRADIENTMAP",
+      14: "INVERSION",
+      15: "EXPOSURE",
+      16: "PHOTOFILTER",
+      17: "SELECTIVECOLOR",
+      18: "SMARTOBJECT",
+      20: "VIBRANCE",
+      21: "VIDEO",
+      22: "BLACKANDWHITE",
+      23: "LAYER3D",
+      26: "COLORLOOKUP"
+    };
+  }
+  /**
+   * Layer kind as an enum-name string (e.g. "LayerKind.NORMAL"). ArtLayer only;
+   * reading it on a LayerSet throws. Check `typename` first.
+   *
+   * @remarks GRADIENTFILL=4 and PATTERNFILL=4 collide in Adobe's enums, so a
+   * kind of 4 always maps to GRADIENTFILL.
+   */
+  get kind() {
+    return evalNumber(this._jsx, `${this._path}.kind`).then(
+      (code) => _PhotoshopLayer._LAYER_KIND_MAP[code] ?? `LayerKind.UNKNOWN_${code}`
+    );
+  }
+  /** Object type name ("ArtLayer" or "LayerSet"). */
+  get typename() {
+    return evalString(this._jsx, `${this._path}.typename`);
+  }
+  // --- Property writes -----------------------------------------------------
+  /** Set the layer name. */
+  async setName(value) {
+    await this._jsx.run(JsxBuilder.assign(`${this._path}.name`, JsxBuilder.string(value)));
+  }
+  /** Set layer visibility. */
+  async setVisible(value) {
+    await this._jsx.run(JsxBuilder.assign(`${this._path}.visible`, JsxBuilder.boolean(value)));
+  }
+  /** Set layer opacity (0-100). */
+  async setOpacity(value) {
+    await this._jsx.run(JsxBuilder.assign(`${this._path}.opacity`, JsxBuilder.number(value)));
+  }
+  /**
+   * Set the blend mode.
+   *
+   * @example
+   * import { BlendMode } from "@ps-generator-bridge/sdk/plugin";
+   * await layer.setBlendMode(BlendMode.MULTIPLY);
+   */
+  async setBlendMode(value) {
+    await this._jsx.run(JsxBuilder.assign(`${this._path}.blendMode`, JsxBuilder.enum_(value)));
+  }
+  /** Set whether the layer is fully locked. */
+  async setAllLocked(value) {
+    await this._jsx.run(JsxBuilder.assign(`${this._path}.allLocked`, JsxBuilder.boolean(value)));
+  }
+  // --- Methods -------------------------------------------------------------
+  /** Delete this layer. */
+  async remove() {
+    await this._jsx.run(`${this._path}.remove()`);
+  }
+  /** Duplicate this layer (the copy becomes `activeLayer`). */
+  async duplicate() {
+    await this._jsx.run(`${this._path}.duplicate()`);
+    return new _PhotoshopLayer(this._jsx, "app.activeDocument.activeLayer");
+  }
+  /**
+   * Move this layer relative to another.
+   *
+   * @param relativeObjectJsxPath JSX path of the reference layer (e.g.
+   *   "app.activeDocument.layers[0]").
+   * @param insertionLocation placement enum.
+   *
+   * @remarks Pass a bare JSX path expression. A `PhotoshopLayers.getByName()`
+   * path contains quotes and cannot be used as a reference expression here.
+   *
+   * @example
+   * import { ElementPlacement } from "@ps-generator-bridge/sdk/plugin";
+   * await layer.move("app.activeDocument.layers[0]", ElementPlacement.PLACEBEFORE);
+   */
+  async move(relativeObjectJsxPath, insertionLocation) {
+    await this._jsx.run(
+      `${this._path}.move(${relativeObjectJsxPath}, ${JsxBuilder.enum_(insertionLocation)})`
+    );
+  }
+  /** Translate the layer by a pixel delta. */
+  async translate(deltaX, deltaY) {
+    await this._jsx.run(
+      JsxBuilder.call(`${this._path}.translate`, [
+        JsxBuilder.number(deltaX),
+        JsxBuilder.number(deltaY)
+      ])
+    );
+  }
+  /**
+   * Scale the layer.
+   *
+   * @param horizontal horizontal scale percent (150 = 150%).
+   * @param vertical vertical scale percent.
+   * @param anchor scaling anchor (optional).
+   */
+  async resize(horizontal, vertical, anchor) {
+    const args = [JsxBuilder.number(horizontal), JsxBuilder.number(vertical)];
+    if (anchor !== void 0) args.push(JsxBuilder.enum_(anchor));
+    await this._jsx.run(JsxBuilder.call(`${this._path}.resize`, args));
+  }
+  /**
+   * Rotate the layer.
+   *
+   * @param angle degrees, clockwise positive.
+   * @param anchor rotation anchor (optional).
+   */
+  async rotate(angle, anchor) {
+    const args = [JsxBuilder.number(angle)];
+    if (anchor !== void 0) args.push(JsxBuilder.enum_(anchor));
+    await this._jsx.run(JsxBuilder.call(`${this._path}.rotate`, args));
+  }
+  /** Move the layer to the end of its stack. */
+  async moveToEnd() {
+    await this._jsx.run(`${this._path}.moveToEnd()`);
+  }
+};
+
+// ../sdk/src/photoshop/PhotoshopLayers.ts
+var PhotoshopLayers = class {
+  constructor(_jsx, _path) {
+    this._jsx = _jsx;
+    this._path = _path;
+  }
+  /** Number of layers in the collection. */
+  get length() {
+    return evalNumber(this._jsx, `${this._path}.length`);
+  }
+  /**
+   * Access a layer by index. The collection is 0-based, matching JavaScript;
+   * `layers[0]` is the top-most layer.
+   */
+  at(index) {
+    return new PhotoshopLayer(this._jsx, `${this._path}[${index}]`);
+  }
+  /**
+   * Look up a layer by name (case-sensitive). The returned wrapper works for
+   * property reads/writes but its path contains a `getByName(...)` call, so it
+   * must not be passed as `PhotoshopLayer.move()`'s reference path.
+   */
+  getByName(name) {
+    const escapedName = JsxBuilder.string(name);
+    return new PhotoshopLayer(this._jsx, `${this._path}.getByName(${escapedName})`);
+  }
+};
+
+// ../sdk/src/photoshop/PhotoshopSelection.ts
+var PhotoshopSelection = class {
+  constructor(_jsx, _path) {
+    this._jsx = _jsx;
+    this._path = _path;
+  }
+  /**
+   * Selection bounds `[left, top, right, bottom]`. Throws when there is no
+   * selection.
+   *
+   * @remarks Units follow `rulerUnits`.
+   */
+  get bounds() {
+    const expr = `(function(){ var b = ${this._path}.bounds; return [b[0], b[1], b[2], b[3]]; })()`;
+    return evalJson(this._jsx, expr);
+  }
+  /** Whether the selection is a solid (un-feathered) rectangle. */
+  get solid() {
+    return evalBool(this._jsx, `${this._path}.solid`);
+  }
+  // --- Methods -------------------------------------------------------------
+  /** Select the whole canvas. */
+  async selectAll() {
+    await this._jsx.run(`${this._path}.selectAll()`);
+  }
+  /** Deselect. */
+  async deselect() {
+    await this._jsx.run(`${this._path}.deselect()`);
+  }
+  /** Invert the selection. */
+  async invert() {
+    await this._jsx.run(`${this._path}.invert()`);
+  }
+  /**
+   * Create a selection from a region of points.
+   *
+   * @param region polygon points, e.g. `[[0,0],[100,0],[100,100],[0,100]]`.
+   * @param type selection operation (optional, defaults to replace).
+   * @param feather feather radius in pixels (optional).
+   * @param antiAlias anti-alias the edges (optional).
+   *
+   * @example
+   * import { SelectionType } from "@ps-generator-bridge/sdk/plugin";
+   * await sel.select([[0,0],[100,0],[100,100],[0,100]], SelectionType.REPLACE, 0, true);
+   */
+  async select(region, type, feather, antiAlias) {
+    const args = [JsxBuilder.regionArray(region)];
+    if (type !== void 0) args.push(JsxBuilder.enum_(type));
+    if (feather !== void 0) args.push(JsxBuilder.number(feather));
+    if (antiAlias !== void 0) args.push(JsxBuilder.boolean(antiAlias));
+    await this._jsx.run(JsxBuilder.call(`${this._path}.select`, args));
+  }
+  /** Grow the selection by `by` pixels. */
+  async expand(by) {
+    await this._jsx.run(JsxBuilder.call(`${this._path}.expand`, [JsxBuilder.number(by)]));
+  }
+  /** Shrink the selection by `by` pixels. */
+  async contract(by) {
+    await this._jsx.run(JsxBuilder.call(`${this._path}.contract`, [JsxBuilder.number(by)]));
+  }
+  /** Feather the selection edge by `by` pixels. */
+  async feather(by) {
+    await this._jsx.run(JsxBuilder.call(`${this._path}.feather`, [JsxBuilder.number(by)]));
+  }
+  /** Translate the selection boundary (content stays put). */
+  async translateBoundary(deltaX, deltaY) {
+    await this._jsx.run(
+      JsxBuilder.call(`${this._path}.translateBoundary`, [
+        JsxBuilder.number(deltaX),
+        JsxBuilder.number(deltaY)
+      ])
+    );
+  }
+};
+
+// ../sdk/src/photoshop/PhotoshopDocument.ts
+var PhotoshopDocument = class _PhotoshopDocument {
+  constructor(_jsx, _path) {
+    this._jsx = _jsx;
+    this._path = _path;
+  }
+  // --- Read-only properties -----------------------------------------------
+  /** Document name (file name, without directory). */
+  get name() {
+    return evalString(this._jsx, `${this._path}.name`);
+  }
+  /** Unique document id. */
+  get id() {
+    return evalNumber(this._jsx, `${this._path}.id`);
+  }
+  /**
+   * Document width.
+   *
+   * @remarks The unit follows Photoshop's current `app.preferences.rulerUnits`.
+   * For guaranteed pixels, set `rulerUnits` to `Units.PIXELS` first (e.g. via
+   * `this.jsx.run(...)`).
+   */
+  get width() {
+    return evalNumber(this._jsx, `${this._path}.width`);
+  }
+  /**
+   * Document height.
+   *
+   * @remarks The unit follows `rulerUnits` (see {@link width}).
+   */
+  get height() {
+    return evalNumber(this._jsx, `${this._path}.height`);
+  }
+  /** Document resolution (PPI). */
+  get resolution() {
+    return evalNumber(this._jsx, `${this._path}.resolution`);
+  }
+  /** Document color mode as an enum-name string (e.g. "DocumentMode.RGB"). */
+  get mode() {
+    const expr = `(function(){
+            var m = ${this._path}.mode;
+            if (m === DocumentMode.RGB) return "DocumentMode.RGB";
+            if (m === DocumentMode.CMYK) return "DocumentMode.CMYK";
+            if (m === DocumentMode.GRAYSCALE) return "DocumentMode.GRAYSCALE";
+            if (m === DocumentMode.LAB) return "DocumentMode.LAB";
+            if (m === DocumentMode.BITMAP) return "DocumentMode.BITMAP";
+            if (m === DocumentMode.INDEXEDCOLOR) return "DocumentMode.INDEXEDCOLOR";
+            if (m === DocumentMode.MULTICHANNEL) return "DocumentMode.MULTICHANNEL";
+            if (m === DocumentMode.DUOTONE) return "DocumentMode.DUOTONE";
+            return String(m);
+        })()`;
+    return evalJson(this._jsx, expr);
+  }
+  /** Whether the document is saved since its last change. */
+  get saved() {
+    return evalBool(this._jsx, `${this._path}.saved`);
+  }
+  /**
+   * Full document path (native `fsName`). For an unsaved document this may
+   * return a temporary path or throw.
+   */
+  get fullName() {
+    return evalString(this._jsx, `${this._path}.fullName.fsName`);
+  }
+  /** Directory containing the document (native `fsName`). */
+  get path() {
+    return evalString(this._jsx, `${this._path}.path.fsName`);
+  }
+  // --- Child navigation (synchronous; no request) -------------------------
+  /** The active layer. */
+  get activeLayer() {
+    return new PhotoshopLayer(this._jsx, `${this._path}.activeLayer`);
+  }
+  /** The Layers collection (ArtLayers + LayerSets). */
+  get layers() {
+    return new PhotoshopLayers(this._jsx, `${this._path}.layers`);
+  }
+  /** The selection. */
+  get selection() {
+    return new PhotoshopSelection(this._jsx, `${this._path}.selection`);
+  }
+  // --- Methods -------------------------------------------------------------
+  /** Save the document in its current format. */
+  async save() {
+    await this._jsx.run(`${this._path}.save()`);
+  }
+  /**
+   * Close the document.
+   *
+   * @param saving save behavior before closing (defaults to not saving).
+   *
+   * @example
+   * import { SaveOptions } from "@ps-generator-bridge/sdk/plugin";
+   * await doc.close(SaveOptions.DONOTSAVECHANGES);
+   */
+  async close(saving = "SaveOptions.DONOTSAVECHANGES") {
+    await this._jsx.run(JsxBuilder.call(`${this._path}.close`, [JsxBuilder.enum_(saving)]));
+  }
+  /**
+   * Save to a path. Mirrors ExtendScript
+   * `saveAs(saveIn, options?, asCopy?, extensionType?)`; only `saveIn` and
+   * `asCopy` are exposed, `options` is undefined and `extensionType` is left to
+   * the Photoshop default.
+   *
+   * @param saveIn destination path.
+   * @param asCopy save as a copy (does not change the document's saved state).
+   */
+  async saveAs(saveIn, asCopy) {
+    const script = `${this._path}.saveAs(${JsxBuilder.file(saveIn)}${asCopy !== void 0 ? `, undefined, ${JsxBuilder.boolean(asCopy)}` : ""})`;
+    await this._jsx.run(script);
+  }
+  /** Flatten all layers into a single background layer. */
+  async flatten() {
+    await this._jsx.run(`${this._path}.flatten()`);
+  }
+  /** Merge all visible layers. */
+  async mergeVisibleLayers() {
+    await this._jsx.run(`${this._path}.mergeVisibleLayers()`);
+  }
+  /** Rasterize all layers. */
+  async rasterizeAllLayers() {
+    await this._jsx.run(`${this._path}.rasterizeAllLayers()`);
+  }
+  /**
+   * Duplicate the document.
+   *
+   * @param name optional name for the copy.
+   * @returns the duplicated document.
+   *
+   * @remarks Assumes `duplicate()` makes the copy the active document, so the
+   * result points at `app.activeDocument`.
+   */
+  async duplicate(name) {
+    const args = name !== void 0 ? [JsxBuilder.string(name)] : [];
+    await this._jsx.run(JsxBuilder.call(`${this._path}.duplicate`, args));
+    return new _PhotoshopDocument(this._jsx, "app.activeDocument");
+  }
+  /**
+   * Resize the canvas.
+   *
+   * @param width new width in pixels.
+   * @param height new height in pixels.
+   * @param anchor anchor position (optional, defaults to center).
+   *
+   * @example
+   * import { AnchorPosition } from "@ps-generator-bridge/sdk/plugin";
+   * await doc.resizeCanvas(1920, 1080, AnchorPosition.MIDDLECENTER);
+   */
+  async resizeCanvas(width, height, anchor) {
+    const args = [JsxBuilder.number(width), JsxBuilder.number(height)];
+    if (anchor !== void 0) args.push(JsxBuilder.enum_(anchor));
+    await this._jsx.run(JsxBuilder.call(`${this._path}.resizeCanvas`, args));
+  }
+  /**
+   * Resize the image.
+   *
+   * @param width new width in pixels (optional).
+   * @param height new height in pixels (optional).
+   * @param resolution new resolution in PPI (optional).
+   */
+  async resizeImage(width, height, resolution) {
+    const args = [
+      width !== void 0 ? JsxBuilder.number(width) : "undefined",
+      height !== void 0 ? JsxBuilder.number(height) : "undefined",
+      resolution !== void 0 ? JsxBuilder.number(resolution) : "undefined"
+    ];
+    await this._jsx.run(JsxBuilder.call(`${this._path}.resizeImage`, args));
+  }
+  /** Rotate the canvas by `angle` degrees. */
+  async rotateCanvas(angle) {
+    await this._jsx.run(JsxBuilder.call(`${this._path}.rotateCanvas`, [JsxBuilder.number(angle)]));
+  }
+  /**
+   * Crop the document to `bounds` `[left, top, right, bottom]` (pixels).
+   *
+   * @remarks Only `bounds` is exposed; ExtendScript `crop()` also takes angle,
+   * width and height — reach those via `this.jsx.run(...)` if needed.
+   */
+  async crop(bounds) {
+    const script = `${this._path}.crop(${JsxBuilder.numberArray(Array.from(bounds))})`;
+    await this._jsx.run(script);
+  }
+};
+
+// ../sdk/src/photoshop/PhotoshopApp.ts
+var PhotoshopApp = class {
+  constructor(_jsx) {
+    this._jsx = _jsx;
+    this._path = "app";
+  }
+  // --- Read-only properties -----------------------------------------------
+  /** Photoshop version (e.g. "25.0"). */
+  get version() {
+    return evalString(this._jsx, `${this._path}.version`);
+  }
+  /** Application locale (e.g. "zh_CN"). */
+  get locale() {
+    return evalString(this._jsx, `${this._path}.locale`);
+  }
+  /** Application name (e.g. "Adobe Photoshop"). */
+  get name() {
+    return evalString(this._jsx, `${this._path}.name`);
+  }
+  /** Internal build number. */
+  get build() {
+    return evalString(this._jsx, `${this._path}.build`);
+  }
+  /**
+   * Install path (native `fsName`). `app.path` is a File in ExtendScript, so the
+   * string comes from `.fsName`.
+   */
+  get path() {
+    return evalString(this._jsx, `${this._path}.path.fsName`);
+  }
+  /**
+   * Current foreground color (RGB).
+   *
+   * @remarks The first version returns only the RGB approximation; in CMYK/Lab
+   * documents this is Photoshop's converted RGB and may lose precision. The
+   * `cmyk` field is reserved and currently always undefined.
+   */
+  get foregroundColor() {
+    const expr = `(function(){
+            var c = ${this._path}.foregroundColor;
+            return {
+                model: "rgb",
+                rgb: { red: c.rgb.red, green: c.rgb.green, blue: c.rgb.blue, hexValue: c.rgb.hexValue }
+            };
+        })()`;
+    return evalJson(this._jsx, expr);
+  }
+  /** Shortcut for `activeDocument` reached through the `app` path. */
+  get activeDocument() {
+    return new PhotoshopDocument(this._jsx, `${this._path}.activeDocument`);
+  }
+  // --- Methods -------------------------------------------------------------
+  /**
+   * Open a file and return its Document wrapper. The opened document becomes the
+   * active document.
+   *
+   * @param filePath native or POSIX path.
+   *
+   * @example
+   * const doc = await this.photoshop.app.open("/Users/me/design.psd");
+   */
+  async open(filePath) {
+    const script = JsxBuilder.call(`${this._path}.open`, [JsxBuilder.file(filePath)]);
+    await this._jsx.run(script);
+    return new PhotoshopDocument(this._jsx, `${this._path}.activeDocument`);
+  }
+  /** Emit a beep. */
+  async beep() {
+    await this._jsx.run(`${this._path}.beep()`);
+  }
+};
+
+// ../sdk/src/photoshop/PsPhotoshopProxy.ts
+var PsPhotoshopProxy = class {
+  constructor(jsx) {
+    this._jsx = jsx;
+    this.app = new PhotoshopApp(this._jsx);
+  }
+  /**
+   * The active document (shortcut for `app.activeDocument`). A fresh wrapper is
+   * created on each access; wrappers are lightweight and stateless.
+   */
+  get activeDocument() {
+    return new PhotoshopDocument(this._jsx, "app.activeDocument");
+  }
+};
+
+// src/server/dispatch.ts
+function unknownMethodResponse(id, method) {
+  return {
+    id,
+    ok: false,
+    error: { code: ErrorCode.UnknownMethod, message: `Unknown method: ${method}` }
+  };
+}
+async function runMethod(handler, message, ctx) {
+  try {
+    const result = await handler(message.params, ctx);
+    return { id: message.id, ok: true, result };
+  } catch (error) {
+    const thrown = error instanceof Error ? error : new Error(String(error));
+    const code = thrown.code;
+    const resolvedCode = typeof code === "string" ? code : ErrorCode.Internal;
+    return {
+      id: message.id,
+      ok: false,
+      error: {
+        code: resolvedCode,
+        message: thrown.message
+      }
+    };
+  }
+}
+
+// src/server/methodTable.ts
+var MethodTable = class {
+  constructor() {
+    this.methods = /* @__PURE__ */ new Map();
+  }
+  register(name, handler) {
+    this.methods.set(name, handler);
+  }
+  async tryDispatch(message, ctx) {
+    if (!isRequest(message)) return void 0;
+    const handler = this.methods.get(message.method);
+    if (!handler) return void 0;
+    return runMethod(handler, message, ctx);
+  }
+};
+
+// src/server/registry.ts
+var Registry = class {
+  constructor(app) {
+    this.app = app;
+    this.methods = new MethodTable();
+    /**
+     * Reserved first path segments (plugin ids). Set by the plugin after plugins
+     * are registered and before modules bootstrap, so a module `@api` whose first
+     * segment collides with a plugin id fails loud at init (RFC 0004).
+     */
+    this.reservedSegments = /* @__PURE__ */ new Set();
+  }
+  /** Register (or replace) a WS Request handler. Runtime-capable. */
+  registerMethod(method, handler) {
+    this.methods.register(method, handler);
+  }
+  /**
+   * Register an HTTP route. Must run before `listen()` (fastify). The handler is
+   * the devkit's opaque `ApiHandler`; cast to fastify's `RouteHandlerMethod` at
+   * this boundary. Throws if the route's first segment is a reserved plugin id.
+   */
+  registerApi(route) {
+    const first = firstSegment(route.url);
+    if (first !== void 0 && this.reservedSegments.has(first)) {
+      throw new Error(`module @api '${route.url}' collides with reserved plugin id '${first}'`);
+    }
+    this.app.route({
+      method: route.method,
+      url: route.url,
+      handler: route.handler
+    });
+  }
+  /**
+   * Route one parsed frame to its method handler, producing a response envelope.
+   * Returns `undefined` for non-request frames (nothing to respond to). This is
+   * the global fallback; per-plugin connections try the scoped table first.
+   */
+  async dispatch(message, ctx) {
+    if (!isRequest(message)) {
+      return void 0;
+    }
+    const response = await this.methods.tryDispatch(message, ctx);
+    if (!response) {
+      return unknownMethodResponse(message.id, message.method);
+    }
+    return response;
+  }
+};
+function firstSegment(url) {
+  const match = url.match(/^\/([^/?#]+)/);
+  return match ? match[1] : void 0;
+}
+
+// src/meta.ts
+var PLUGIN_NAME = "PS Generator Bridge Service";
+var PLUGIN_VERSION = "0.1.0";
+
+// src/server/builtins.ts
+function registerBuiltins(registry, plugins) {
+  registry.registerMethod(ProtocolMethod.GetServerInfo, async (_params, ctx) => {
+    const { generator } = ctx;
+    let psVersion;
+    try {
+      psVersion = await generator.getPhotoshopVersion();
+    } catch {
+      psVersion = void 0;
+    }
+    return { name: PLUGIN_NAME, version: PLUGIN_VERSION, psVersion, plugins: plugins() };
+  });
+  registry.registerMethod(ProtocolMethod.JsxRun, async (params, ctx) => {
+    const context = ctx;
+    const { script } = params;
+    if (typeof script !== "string") throw badRequest("script is required");
+    if (!context.jsx) throw badRequest("jsx is not available");
+    return context.jsx.run(script);
+  });
+  registry.registerMethod(ProtocolMethod.JsxExecute, async (params, ctx) => {
+    const context = ctx;
+    const { name, params: jsxParams } = params;
+    if (typeof name !== "string") throw badRequest("name is required");
+    if (!context.jsx) throw badRequest("jsx is not available");
+    return context.jsx.execute(name, jsxParams);
+  });
+  registry.registerMethod(ProtocolMethod.EventSubscribe, async (params, ctx) => {
+    const context = ctx;
+    if (!context.session) throw badRequest("event subscription is only available on /ws");
+    const { type } = params;
+    if (typeof type !== "string") throw badRequest("type is required");
+    context.session.subscribe(type);
+    return { ok: true };
+  });
+  registry.registerMethod(ProtocolMethod.EventUnsubscribe, async (params, ctx) => {
+    const context = ctx;
+    if (!context.session) throw badRequest("event subscription is only available on /ws");
+    const { type } = params;
+    if (typeof type !== "string") throw badRequest("type is required");
+    context.session.unsubscribe(type);
+    return { ok: true };
+  });
+}
+function badRequest(message) {
+  const error = new Error(message);
+  error.code = ErrorCode.BadRequest;
+  return error;
+}
+
+// ../sdk/src/plugin/base.ts
+var BASE_PLUGIN_BRAND = /* @__PURE__ */ Symbol.for("ps-generator-bridge.BasePlugin");
+var BasePlugin = class {
+  constructor(id, plugin) {
+    this.id = id;
+    this.plugin = plugin;
+  }
+  /** Feature modules, reached by short key (shortcut for `this.plugin.modules`). */
+  get modules() {
+    return this.plugin.modules;
+  }
+  /**
+   * The jsx runner scoped to this plugin's own `jsx/` dir (shortcut for
+   * `this.plugin.jsx`, RFC 0005). `jsx.execute("x")` runs `<pluginRoot>/jsx/x.jsx`;
+   * `jsx.executeBuiltin("Document/getDocumentInfo")` reaches the host's built-in
+   * tree.
+   */
+  get jsx() {
+    return this.plugin.jsx;
+  }
+  /**
+   * Typed, listen-only Photoshop event stream (shortcut for `this.plugin.events`).
+   * Subscriptions are lazy on the server side: the first `on`/`once` for an event
+   * subscribes upstream, and the last `off` unsubscribes.
+   */
+  get events() {
+    return this.plugin.events;
+  }
+  /**
+   * Photoshop DOM proxy, a typed object wrapper over `this.jsx`. Read and write
+   * the live document through `this.photoshop.app` / `this.photoshop.activeDocument`
+   * (e.g. `await this.photoshop.activeDocument.name`) instead of hand-writing
+   * ExtendScript. Lazily built once and backed by this plugin's own jsx runner;
+   * drop to `this.jsx.run(...)` for anything the proxy does not cover.
+   */
+  get photoshop() {
+    return this._photoshop ??= new PsPhotoshopProxy(this.jsx);
+  }
+  /**
+   * Attach the per-plugin client bus. Called by the server's assembler after
+   * construction and before `listen`, so `broadcast`/`send` are live by the time
+   * any handler can fire. Not part of the public Plugin authoring API.
+   */
+  _attachBus(bus) {
+    this.bus = bus;
+  }
+  /** Push an Event to every online client of this plugin. */
+  broadcast(type, data) {
+    this.bus?.broadcast(type, data);
+  }
+  /** Push an Event to one client of this plugin (no-op if not connected). */
+  send(clientId, type, data) {
+    this.bus?.send(clientId, type, data);
+  }
+  /** Called after a client handshake registers with this plugin. Default no-op. */
+  onConnect(_clientId) {
+  }
+  /** Called after a client socket is removed from this plugin. Default no-op. */
+  onDisconnect(_clientId) {
+  }
+};
+Object.defineProperty(BasePlugin.prototype, BASE_PLUGIN_BRAND, {
+  value: true,
+  enumerable: false,
+  configurable: false,
+  writable: false
+});
+function isBasePluginClass(S) {
+  if (typeof S !== "function") return false;
+  const proto = S.prototype;
+  return proto != null && Boolean(proto[BASE_PLUGIN_BRAND]);
+}
+
+// ../sdk/src/plugin/decorators.ts
+Symbol.metadata ??= /* @__PURE__ */ Symbol.for("Symbol.metadata");
+var METADATA = Symbol.metadata;
+var HANDLERS = /* @__PURE__ */ Symbol.for("ps-generator-bridge.handlers");
+function pushHandler(metadata, meta) {
+  if (!Object.prototype.hasOwnProperty.call(metadata, HANDLERS)) {
+    metadata[HANDLERS] = [];
+  }
+  metadata[HANDLERS].push(meta);
+}
+function ws(name) {
+  return function(_value, context) {
+    pushHandler(context.metadata, {
+      kind: "ws",
+      name,
+      methodKey: String(context.name)
+    });
+  };
+}
+function bootstrap(instance, target) {
+  const ctor = instance.constructor;
+  const collected = [];
+  let metadata = ctor[METADATA];
+  while (metadata) {
+    if (Object.prototype.hasOwnProperty.call(metadata, HANDLERS)) {
+      collected.push(...metadata[HANDLERS]);
+    }
+    metadata = Object.getPrototypeOf(metadata);
+  }
+  for (const meta of collected) {
+    const fn = instance[meta.methodKey];
+    if (typeof fn !== "function") continue;
+    const bound = fn.bind(instance);
+    if (meta.kind === "ws") {
+      target.registerMethod(meta.name, bound);
+    } else {
+      target.registerApi({ method: meta.method, url: meta.url, handler: bound });
+    }
+  }
+}
+
+// src/server/clientStore.ts
+var ClientStore = class {
+  constructor() {
+    this.clients = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Register `socket` under `clientId`. If an entry already exists (a reconnect
+   * whose old socket is still half-open), the new connection takes over: the old
+   * socket is closed and the entry replaced, but subscriptions are preserved.
+   */
+  add(clientId, socket) {
+    const existing = this.clients.get(clientId);
+    const subscriptions = existing?.subscriptions ?? /* @__PURE__ */ new Set();
+    const entry = { clientId, socket, connectedAt: Date.now(), subscriptions };
+    this.clients.set(clientId, entry);
+    if (existing && existing.socket !== socket) {
+      try {
+        existing.socket.close();
+      } catch {
+      }
+    }
+    return entry;
+  }
+  /**
+   * Drop the entry for `clientId` — but only if `socket` is still the current
+   * one. A taken-over old socket firing `close` must not evict the live entry.
+   */
+  remove(clientId, socket) {
+    const entry = this.clients.get(clientId);
+    if (entry && entry.socket === socket) {
+      this.clients.delete(clientId);
+      return entry;
+    }
+    return void 0;
+  }
+  subscribe(clientId, type) {
+    const entry = this.clients.get(clientId);
+    if (!entry || entry.subscriptions.has(type)) return false;
+    entry.subscriptions.add(type);
+    return true;
+  }
+  unsubscribe(clientId, type) {
+    const entry = this.clients.get(clientId);
+    if (!entry || !entry.subscriptions.has(type)) return false;
+    entry.subscriptions.delete(type);
+    return true;
+  }
+  /** Push an Event to one client (no-op if it is not connected). */
+  emit(clientId, type, data) {
+    const entry = this.clients.get(clientId);
+    if (entry) {
+      sendEvent(entry.socket, type, data);
+    }
+  }
+  /** Push an Event to every connected client. */
+  broadcast(type, data) {
+    for (const entry of this.clients.values()) {
+      sendEvent(entry.socket, type, data);
+    }
+  }
+  /** Push an Event only to clients subscribed to that Event type. */
+  broadcastSubscribed(type, data) {
+    for (const entry of this.clients.values()) {
+      if (entry.subscriptions.has(type)) {
+        sendEvent(entry.socket, type, data);
+      }
+    }
+  }
+};
+function sendEvent(socket, type, data) {
+  socket.send(serializeFrame({ type, data }));
+}
+
+// src/server/scopedRegistry.ts
+var ScopedRegistry = class {
+  constructor() {
+    this.methods = new MethodTable();
+    this.apiRoutes = [];
+  }
+  registerMethod(name, handler) {
+    this.methods.register(name, handler);
+  }
+  registerApi(route) {
+    this.apiRoutes.push(route);
+  }
+  /** The `@api` routes bootstrap collected, for the assembler to flush to fastify. */
+  get routes() {
+    return this.apiRoutes;
+  }
+  /**
+   * Dispatch a frame against the scoped table. Returns `undefined` when there is
+   * no scoped handler (caller falls back to the global Registry) or the frame is
+   * not a request (nothing to respond to). A found handler always yields an
+   * envelope — including an error envelope — so only "not in this table" falls
+   * through.
+   */
+  async tryDispatch(message, ctx) {
+    return this.methods.tryDispatch(message, ctx);
+  }
+};
+
+// src/server/pluginManager.ts
+var PluginManager = class {
+  constructor(app) {
+    this.app = app;
+    this.plugins = /* @__PURE__ */ new Map();
+  }
+  /** All registered plugin ids, in registration order. */
+  get ids() {
+    return [...this.plugins.keys()];
+  }
+  /** The discovery list surfaced at `GET /plugins` and in `getServerInfo`. */
+  list() {
+    return [...this.plugins.values()].map((e) => ({ id: e.plugin.id }));
+  }
+  /** Look up a loaded plugin by id (used by the `/ws/:pluginId` route). */
+  get(id) {
+    return this.plugins.get(id);
+  }
+  /**
+   * Register a plugin: build its scoped table + ClientStore, attach the client
+   * bus, bootstrap its handlers, and flush its `@api` routes to fastify. Throws
+   * on a duplicate or illegal id. Must run before `listen()`.
+   */
+  register(plugin) {
+    const id = plugin.id;
+    if (!isValidPluginId(id)) {
+      throw new Error(`illegal plugin id: '${id}' (must match [A-Za-z0-9_-]+)`);
+    }
+    if (this.plugins.has(id)) {
+      throw new Error(`duplicate plugin id: ${id}`);
+    }
+    const scoped = new ScopedRegistry();
+    const clients = new ClientStore();
+    const bus = {
+      broadcast: (type, data) => clients.broadcast(type, data),
+      send: (clientId, type, data) => clients.emit(clientId, type, data)
+    };
+    plugin._attachBus(bus);
+    bootstrap(plugin, scoped);
+    for (const route of scoped.routes) {
+      this.app.route({
+        method: route.method,
+        url: `/${id}${route.url}`,
+        handler: route.handler
+      });
+    }
+    const entry = { plugin, scoped, clients };
+    this.plugins.set(id, entry);
+    return entry;
+  }
+};
+function isValidPluginId(id) {
+  return /^[A-Za-z0-9_-]+$/.test(id);
+}
+
+// src/utilis/eventManager.ts
+var import_node_events = require("events");
+var PHOTOSHOP_EVENTS = [
+  "workspaceChanged",
+  "toolChanged",
+  "quickMaskStateChanged",
+  "documentChanged",
+  "closedDocument",
+  "newDocumentViewCreated",
+  "activeViewChanged",
+  "currentDocumentChanged",
+  "backgroundColorChanged",
+  "foregroundColorChanged",
+  "imageChanged"
+];
+var ALLOWED = new Set(PHOTOSHOP_EVENTS);
+var META = /* @__PURE__ */ new Set(["newListener", "removeListener", "error"]);
+var EventManager = class extends import_node_events.EventEmitter {
+  constructor(generator) {
+    super();
+    this.generator = generator;
+    // One bridge listener per active event, kept so we can detach the exact
+    // function from the generator when the last consumer unsubscribes.
+    this.bridges = /* @__PURE__ */ new Map();
+    super.on("newListener", (event) => this.onAdd(event));
+    super.on("removeListener", (event) => this.onRemove(event));
+  }
+  // --- typed surface (narrows EventEmitter's string|symbol signatures) ------
+  on(event, listener) {
+    return super.on(event, listener);
+  }
+  once(event, listener) {
+    return super.once(event, listener);
+  }
+  addListener(event, listener) {
+    return super.addListener(event, listener);
+  }
+  off(event, listener) {
+    return super.off(event, listener);
+  }
+  removeListener(event, listener) {
+    return super.removeListener(event, listener);
+  }
+  emit(event, ...args) {
+    return super.emit(event, ...args);
+  }
+  // --- lazy subscribe / unsubscribe ----------------------------------------
+  /** First listener for a PS event -> subscribe upstream once. */
+  onAdd(event) {
+    if (typeof event !== "string" || META.has(event)) return;
+    if (!ALLOWED.has(event)) {
+      throw new Error(`EventManager: unknown Photoshop event "${event}"`);
+    }
+    const key = event;
+    if (this.listenerCount(key) !== 0) return;
+    const bridge = (payload) => this.emit(key, payload);
+    this.bridges.set(key, bridge);
+    this.generator.onPhotoshopEvent(event, bridge);
+  }
+  /** Last listener for a PS event removed -> detach the upstream bridge. */
+  onRemove(event) {
+    if (typeof event !== "string" || META.has(event)) return;
+    const key = event;
+    if (this.listenerCount(key) !== 0) return;
+    const bridge = this.bridges.get(key);
+    if (!bridge) return;
+    this.generator.removePhotoshopEventListener(event, bridge);
+    this.bridges.delete(key);
+  }
+};
+
+// src/server/eventHub.ts
+var ALLOWED2 = new Set(PHOTOSHOP_EVENTS);
+var EventHub = class {
+  constructor(events, clients) {
+    this.events = events;
+    this.clients = clients;
+    this.refs = /* @__PURE__ */ new Map();
+    this.bridges = /* @__PURE__ */ new Map();
+  }
+  subscribe(type) {
+    const key = this.assertEvent(type);
+    const next = (this.refs.get(key) ?? 0) + 1;
+    this.refs.set(key, next);
+    if (next !== 1) return;
+    const bridge = (payload) => this.clients.broadcastSubscribed(type, payload);
+    this.bridges.set(key, bridge);
+    this.events.on(key, bridge);
+  }
+  unsubscribe(type) {
+    const key = this.assertEvent(type);
+    const current = this.refs.get(key) ?? 0;
+    if (current <= 1) {
+      this.refs.delete(key);
+      const bridge = this.bridges.get(key);
+      if (bridge) {
+        this.events.off(key, bridge);
+        this.bridges.delete(key);
+      }
+      return;
+    }
+    this.refs.set(key, current - 1);
+  }
+  assertEvent(type) {
+    if (!ALLOWED2.has(type)) {
+      throw new Error(`Unknown Photoshop event: ${type}`);
+    }
+    return type;
+  }
+};
+
+// src/server/index.ts
+var DEFAULT_PORT = 7700;
+function createServer(options) {
+  const { port, host = "127.0.0.1", generator, jsx, events, logger } = options;
+  const app = (0, import_fastify.default)({ logger: false });
+  let boundPort = 0;
+  const pluginManager = new PluginManager(app);
+  const registry = new Registry(app);
+  registerBuiltins(registry, () => pluginManager.list());
+  const rootClients = new ClientStore();
+  const rootEvents = events ? new EventHub(events, rootClients) : void 0;
+  app.get("/health", async () => ({ status: "ok" }));
+  app.get("/plugins", async () => ({ plugins: pluginManager.list() }));
+  app.register(import_websocket.default);
+  app.register(async (instance) => {
+    instance.get("/ws", { websocket: true }, (socket, req) => {
+      const query = req.query;
+      const requested = query?.id;
+      const clientId = requested && requested.length > 0 ? requested : (0, import_node_crypto.randomUUID)();
+      rootClients.add(clientId, socket);
+      logger.info(`client connected: ${clientId} -> root`);
+      socket.send(serializeFrame({ type: "connected", data: { clientId } }));
+      const session = {
+        clientId,
+        subscribe: (type) => {
+          const added = rootClients.subscribe(clientId, type);
+          if (!added) return;
+          try {
+            rootEvents?.subscribe(type);
+          } catch (error) {
+            rootClients.unsubscribe(clientId, type);
+            throw error;
+          }
+        },
+        unsubscribe: (type) => {
+          const removed = rootClients.unsubscribe(clientId, type);
+          if (removed) rootEvents?.unsubscribe(type);
+        }
+      };
+      const ctx = { generator, jsx, session };
+      socket.on("message", (data) => {
+        void handleRootFrame(socket, String(data), registry, ctx, logger);
+      });
+      socket.on("close", () => {
+        const removed = rootClients.remove(clientId, socket);
+        releaseSubscriptions(removed, rootEvents);
+        logger.info(`client disconnected: ${clientId} -> root`);
+      });
+      socket.on("error", (error) => logger.error("socket error", error));
+    });
+    instance.get("/ws/:pluginId", { websocket: true }, (socket, req) => {
+      const pluginId = req.params.pluginId;
+      const entry = pluginManager.get(pluginId);
+      if (!entry) {
+        socket.send(
+          serializeFrame({
+            type: "error",
+            data: { code: "UNKNOWN_PLUGIN", message: `unknown plugin: ${pluginId}`, pluginId }
+          })
+        );
+        socket.close();
+        return;
+      }
+      const query = req.query;
+      const requested = query?.id;
+      const clientId = requested && requested.length > 0 ? requested : (0, import_node_crypto.randomUUID)();
+      entry.clients.add(clientId, socket);
+      entry.plugin.onConnect(clientId);
+      logger.info(`client connected: ${clientId} -> plugin ${pluginId}`);
+      socket.send(serializeFrame({ type: "connected", data: { clientId } }));
+      const ctx = { generator, jsx };
+      socket.on("message", (data) => {
+        void handlePluginFrame(socket, String(data), entry, registry, ctx, logger);
+      });
+      socket.on("close", () => {
+        entry.clients.remove(clientId, socket);
+        entry.plugin.onDisconnect(clientId);
+        logger.info(`client disconnected: ${clientId} -> plugin ${pluginId}`);
+      });
+      socket.on("error", (error) => logger.error("socket error", error));
+    });
+  });
+  return {
+    get port() {
+      return boundPort;
+    },
+    registry,
+    pluginManager,
+    listen: async () => {
+      await app.listen({ port, host });
+      const address = app.server.address();
+      boundPort = typeof address === "object" && address ? address.port : port;
+      logger.info(
+        `PS Generator Bridge server listening on http://${host}:${boundPort} (ws + /health + /plugins)`
+      );
+    },
+    close: () => app.close()
+  };
+}
+async function handleRootFrame(socket, data, registry, ctx, logger) {
+  let parsed;
+  try {
+    parsed = parseFrame(data);
+  } catch {
+    logger.warn("dropping non-JSON frame");
+    return;
+  }
+  const response = await registry.dispatch(parsed, ctx);
+  if (response) {
+    socket.send(serializeFrame(response));
+  }
+}
+function releaseSubscriptions(entry, hub) {
+  if (!entry || !hub) return;
+  for (const type of entry.subscriptions) {
+    hub.unsubscribe(type);
+  }
+}
+async function handlePluginFrame(socket, data, entry, registry, ctx, logger) {
+  let parsed;
+  try {
+    parsed = parseFrame(data);
+  } catch {
+    logger.warn("dropping non-JSON frame");
+    return;
+  }
+  const response = await entry.scoped.tryDispatch(parsed, ctx) ?? await registry.dispatch(parsed, ctx);
+  if (response) {
+    socket.send(serializeFrame(response));
+  }
+}
+
+// src/server/pluginLoader.ts
+var import_node_fs = require("fs");
+var import_node_path = require("path");
+var import_node_url = require("url");
+async function loadPlugins(options) {
+  const { pluginsDir, hostFor, knownIds, logger } = options;
+  const loaded = [];
+  const skipped = [];
+  const taken = new Set(knownIds);
+  let dirs;
+  try {
+    dirs = scanPluginDirs(pluginsDir);
+  } catch (err) {
+    logger.debug(`pluginsDir not loaded: ${pluginsDir} (${err.message})`);
+    return { loaded, skipped };
+  }
+  for (const name of dirs) {
+    const dir = (0, import_node_path.join)(pluginsDir, name);
+    const outcome = await loadOne(dir, hostFor, taken);
+    if (outcome.kind === "loaded") {
+      loaded.push({ id: outcome.id, plugin: outcome.plugin, path: outcome.path });
+      taken.add(outcome.id);
+      logger.info(`plugin loaded: ${name} (${outcome.id})`);
+    } else {
+      skipped.push({ path: name, reason: outcome.reason });
+      logger.warn(`plugin skipped: ${name} \u2014 ${outcome.reason}`);
+    }
+  }
+  return { loaded, skipped };
+}
+async function loadOne(dir, hostFor, taken) {
+  let pkg;
+  try {
+    pkg = JSON.parse((0, import_node_fs.readFileSync)((0, import_node_path.join)(dir, "package.json"), "utf8"));
+  } catch (err) {
+    return {
+      kind: "skipped",
+      reason: `package.json missing or invalid: ${err.message}`
+    };
+  }
+  if (typeof pkg.main !== "string" || pkg.main.length === 0) {
+    return { kind: "skipped", reason: 'package.json has no "main"' };
+  }
+  const root = (0, import_node_path.resolve)(dir);
+  const entry = (0, import_node_path.resolve)(root, pkg.main);
+  if (entry !== root && !entry.startsWith(root + import_node_path.sep)) {
+    return { kind: "skipped", reason: `"main" escapes the plugin directory: ${pkg.main}` };
+  }
+  let mod;
+  try {
+    mod = await import((0, import_node_url.pathToFileURL)(entry).href);
+  } catch (err) {
+    return { kind: "skipped", reason: `load failed: ${err.message}` };
+  }
+  let S = mod.default ?? mod;
+  if (S !== null && typeof S === "object") {
+    const inner = S.default;
+    if (inner !== void 0) S = inner;
+  }
+  if (!isBasePluginClass(S)) {
+    return { kind: "skipped", reason: "default export is not a BasePlugin subclass" };
+  }
+  const id = S.id;
+  if (typeof id !== "string" || id.length === 0) {
+    return { kind: "skipped", reason: "missing static id" };
+  }
+  if (!isValidPluginId(id)) {
+    return { kind: "skipped", reason: `illegal id '${id}' (must match [A-Za-z0-9_-]+)` };
+  }
+  if (taken.has(id)) {
+    return { kind: "skipped", reason: `duplicate id '${id}'` };
+  }
+  try {
+    const host = hostFor(dir);
+    const plugin = new S(id, host);
+    return { kind: "loaded", id, plugin, path: entry };
+  } catch (err) {
+    return { kind: "skipped", reason: `construct failed: ${err.message}` };
+  }
+}
+function scanPluginDirs(dir) {
+  return (0, import_node_fs.readdirSync)(dir, { withFileTypes: true }).filter((e) => e.isDirectory() && e.name !== "node_modules" && !e.name.startsWith(".")).map((e) => e.name).sort();
+}
+
+// src/utilis/jsxRunner.ts
+var import_promises = require("fs/promises");
+var import_node_path2 = require("path");
+var ERROR_PREFIX = "Error:";
+var JsxRunner = class {
+  constructor(generator, logger, polyfillsDir = (0, import_node_path2.join)(__dirname, "..", "jsx", "polyfills")) {
+    this.generator = generator;
+    this.logger = logger;
+    this.polyfillsDir = polyfillsDir;
+    this.jsxDir = (0, import_node_path2.join)(__dirname, "..", "jsx");
+    this.polyfillsCache = "";
+  }
+  /**
+   * A jsx runner scoped to a plugin's own `jsx/` dir (RFC 0005). The returned
+   * handle's `execute` resolves under `dir`, while `executeBuiltin` still targets
+   * the built-in tree; `run` is unchanged. The scope is the *only* per-plugin
+   * state — there is no shared mutable registry; the host builds one of these per
+   * plugin in `hostFor` and injects it as `plugin.jsx`.
+   */
+  forPlugin(dir) {
+    return new ScopedJsx(this, dir);
+  }
+  /**
+   * Resolve a jsx name to an absolute `.jsx` path under `baseDir`. The name may
+   * carry domain subdirs (e.g. `Document/getDocumentInfo`). No escape guard: jsx
+   * names come from trusted in-process code (a module or a plugin's own source),
+   * which already runs arbitrary JS, so a guard would add no boundary.
+   */
+  resolvePath(baseDir, name) {
+    return (0, import_node_path2.join)(baseDir, `${name}.jsx`);
+  }
+  /**
+   * Prime the default ExtendScript engine with ES polyfills. Reads every
+   * `*.js` file under `polyfillsDir` (recursively, sorted by relative path for
+   * deterministic concatenation order), concatenates them into `polyfillsCache`,
+   * and evaluates the bundle once. Must be awaited before any `execute` call
+   * that depends on the polyfills; `PsBridgeHost.onInit` does this before
+   * `server.listen`.
+   *
+   * Missing dir -> throw (packaging bug). Empty dir -> no-op. Injection
+   * returning `"Error:…"` or rejecting -> throw, so a broken polyfill surfaces
+   * at startup rather than as a runtime `find is not a function`.
+   */
+  async init() {
+    const files = await this.collectPolyfillFiles();
+    if (files.length === 0) {
+      this.logger.debug("polyfills dir empty, skipping injection");
+      this.polyfillsCache = "";
+      return;
+    }
+    const parts = await Promise.all(files.map((file) => (0, import_promises.readFile)(file, "utf8")));
+    this.polyfillsCache = parts.join("\n");
+    const value = await this.generator.evaluateJSXString(this.polyfillsCache);
+    if (typeof value === "string" && value.startsWith(ERROR_PREFIX)) {
+      throw new Error(value.slice(ERROR_PREFIX.length));
+    }
+    this.logger.debug(`polyfills injected: ${files.length} files`);
+  }
+  /**
+   * Run the jsx registered under `name` in the built-in `jsx/` tree (domain
+   * subdirs included, e.g. `Document/getDocumentInfo`). `params` are inlined into
+   * the script; `sharedEngineSafe` opts into Photoshop's shared script engine.
+   * The root runner's own scope *is* the built-in tree, so `execute` and
+   * `executeBuiltin` coincide here; a plugin's scoped view (see `forPlugin`)
+   * splits them apart.
+   */
+  async execute(name, params, sharedEngineSafe) {
+    return this.executeIn(this.jsxDir, name, params, sharedEngineSafe);
+  }
+  /**
+   * Alias of `execute` on the root runner — always the built-in tree. Present so
+   * the root satisfies `JsxRunnerApi` alongside the scoped view; the scoped view
+   * overrides `execute` (plugin dir) while delegating `executeBuiltin` here.
+   */
+  async executeBuiltin(name, params, sharedEngineSafe) {
+    return this.execute(name, params, sharedEngineSafe);
+  }
+  /**
+   * Run the jsx under `name` resolved against `baseDir`. The seam through which
+   * both the root runner (built-in tree) and the scoped view (a plugin's dir)
+   * reach Photoshop; keeps path resolution + result normalization in one place.
+   *
+   * @internal Server-internal — not on `JsxRunnerApi`, not reachable by plugins.
+   * Public only so the sibling `ScopedJsx` can delegate to it.
+   */
+  async executeIn(baseDir, name, params, sharedEngineSafe) {
+    const path = this.resolvePath(baseDir, name);
+    const value = await this.generator.evaluateJSXFile(path, params, sharedEngineSafe);
+    return this.normalizeJsxResult(value);
+  }
+  /**
+   * Evaluate an arbitrary jsx string in the default ExtendScript engine (the
+   * same engine `init()` primed with polyfills). No `sharedEngineSafe` opt-out:
+   * polyfills live only in the default engine, so a shared-engine variant would
+   * be silently un-polyfilled. Return value follows the same convention as
+   * `run` — verbatim, with `"Error:"`-prefixed strings turned into thrown
+   * Errors.
+   */
+  async run(script) {
+    const value = await this.generator.evaluateJSXString(script);
+    return this.normalizeJsxResult(value);
+  }
+  /**
+   * Open a built-in packaged jsx file via the low-level `_sendJSXFile` channel
+   * and return a typed handle to its in-flight evaluation. A root-runner-only
+   * seam (not on `JsxRunnerApi`): the only caller is `ImageModule.getPixmap`.
+   * Plugins reach pixmaps through `plugin.modules.image`, not this channel.
+   *
+   * Unlike `run` (which
+   * awaits a single resolved value), this exposes the raw progress stream so
+   * the caller can collect the multi-message responses Photoshop emits for
+   * pixmap-producing scripts (bounds + pixmap + optional ICC profile). The
+   * caller owns completion: it must call `channel.resolve()` once it has
+   * received every message it expected, or `channel.reject(err)` on failure.
+   *
+   * `sharedEngineSafe` defaults to `true` to match the pixmap protocol
+   * (generator-core's `getPixmap` / `getDocumentPixmap` both use the shared
+   * engine).
+   */
+  openJSXFile(name, params, sharedEngineSafe = true) {
+    const path = this.resolvePath(this.jsxDir, name);
+    const deferred = this.generator._sendJSXFile(path, params, sharedEngineSafe);
+    return {
+      onProgress: (fn) => {
+        deferred.promise.progress(fn);
+      },
+      onFail: (fn) => {
+        deferred.promise.fail(fn);
+      },
+      resolve: () => {
+        deferred.resolve();
+      },
+      reject: (err) => {
+        deferred.reject(err);
+      }
+    };
+  }
+  /**
+   * Shared result normalization for `run` and `execute`: a string starting with
+   * `"Error:"` becomes a thrown `Error` carrying the remainder; everything else
+   * is returned verbatim (no `JSON.parse` — `T` is a labelling convenience).
+   */
+  normalizeJsxResult(value) {
+    if (typeof value === "string" && value.startsWith(ERROR_PREFIX)) {
+      throw new Error(value.slice(ERROR_PREFIX.length));
+    }
+    return value;
+  }
+  /**
+   * Recursively list `*.js` files under `polyfillsDir`, sorted by relative path
+   * (POSIX-normalized) so concatenation order is stable across platforms and
+   * polyfills that depend on each other load in a fixed sequence. Throws if the
+   * directory itself is missing.
+   */
+  async collectPolyfillFiles() {
+    const discovered = [];
+    const walk = async (dir) => {
+      let entries;
+      try {
+        entries = await (0, import_promises.readdir)(dir, { withFileTypes: true });
+      } catch (error) {
+        if (dir === this.polyfillsDir) {
+          throw new Error(`polyfills dir not found: ${this.polyfillsDir}`);
+        }
+        throw error;
+      }
+      for (const entry of entries) {
+        const full = (0, import_node_path2.join)(dir, entry.name);
+        if (entry.isDirectory()) {
+          await walk(full);
+        } else if (entry.isFile() && entry.name.endsWith(".js")) {
+          discovered.push(full);
+        }
+      }
+    };
+    await walk(this.polyfillsDir);
+    return discovered.sort((a, b) => {
+      const ra = (0, import_node_path2.relative)(this.polyfillsDir, a).split(import_node_path2.sep).join("/");
+      const rb = (0, import_node_path2.relative)(this.polyfillsDir, b).split(import_node_path2.sep).join("/");
+      return ra < rb ? -1 : ra > rb ? 1 : 0;
+    });
+  }
+};
+var ScopedJsx = class {
+  constructor(root, baseDir) {
+    this.root = root;
+    this.baseDir = baseDir;
+  }
+  execute(name, params, sharedEngineSafe) {
+    return this.root.executeIn(this.baseDir, name, params, sharedEngineSafe);
+  }
+  executeBuiltin(name, params, sharedEngineSafe) {
+    return this.root.execute(name, params, sharedEngineSafe);
+  }
+  run(script) {
+    return this.root.run(script);
+  }
+};
+
+// src/modules/base.ts
+var BaseModule = class {
+  constructor(name, plugin) {
+    this.name = name;
+    this.plugin = plugin;
+  }
+};
+
+// src/modules/action/index.ts
+var _removeBackground_dec, _autoCutout_dec, _a, _init;
+var ActionModule = class extends (_a = BaseModule, _autoCutout_dec = [ws(ProtocolMethod.ActionAutoCutout)], _removeBackground_dec = [ws(ProtocolMethod.ActionRemoveBackground)], _a) {
+  constructor(plugin) {
+    super("action", plugin);
+    __runInitializers(_init, 5, this);
+  }
+  async autoCutout() {
+    await this.plugin.jsx.execute("Action/autoCutout");
+    return true;
+  }
+  async removeBackground() {
+    const result = await this.plugin.jsx.execute("Action/removeBackground");
+    return { success: result };
+  }
+};
+_init = __decoratorStart(_a);
+__decorateElement(_init, 1, "autoCutout", _autoCutout_dec, ActionModule);
+__decorateElement(_init, 1, "removeBackground", _removeBackground_dec, ActionModule);
+__decoratorMetadata(_init, ActionModule);
+
+// src/modules/document/index.ts
+var _saveDocument_dec, _exportDocument_dec, _getCurrentDocument_dec, _a2, _init2;
+var DocumentModule = class extends (_a2 = BaseModule, _getCurrentDocument_dec = [ws(ProtocolMethod.DocumentCurrent)], _exportDocument_dec = [ws(ProtocolMethod.DocumentExport)], _saveDocument_dec = [ws(ProtocolMethod.DocumentSave)], _a2) {
+  constructor(plugin) {
+    super("document", plugin);
+    __runInitializers(_init2, 5, this);
+    this.currentDocument = null;
+  }
+  async getCurrentDocument() {
+    const data = await this.plugin.jsx.execute("Document/getDocumentInfo");
+    if (!data) throw new Error("No document is opened");
+    return data;
+  }
+  async exportDocument(params) {
+    if (!params.filePath) throw new Error("filePath is required");
+    return await this.plugin.jsx.execute("Document/exportDocument", params);
+  }
+  async saveDocument(params) {
+    return await this.plugin.jsx.execute("Document/saveDocument", params);
+  }
+};
+_init2 = __decoratorStart(_a2);
+__decorateElement(_init2, 1, "getCurrentDocument", _getCurrentDocument_dec, DocumentModule);
+__decorateElement(_init2, 1, "exportDocument", _exportDocument_dec, DocumentModule);
+__decorateElement(_init2, 1, "saveDocument", _saveDocument_dec, DocumentModule);
+__decoratorMetadata(_init2, DocumentModule);
+
+// src/modules/layer/index.ts
+var _getLayerInfoByIndex_dec, _getLayerInfoByID_dec, _getLayerInfo_dec, _a3, _init3;
+var LayerModule = class extends (_a3 = BaseModule, _getLayerInfo_dec = [ws(ProtocolMethod.LayerGetInfo)], _getLayerInfoByID_dec = [ws(ProtocolMethod.LayerGetInfoById)], _getLayerInfoByIndex_dec = [ws(ProtocolMethod.LayerGetInfoByIndex)], _a3) {
+  constructor(plugin) {
+    super("layer", plugin);
+    __runInitializers(_init3, 5, this);
+  }
+  async getLayerInfo(options) {
+    return await this.plugin.jsx.execute("Layer/getLayerInfo", {
+      layerID: options?.id,
+      layerIndex: options?.index,
+      getChildren: options?.getChildren,
+      getGeneratorSettings: options?.getGeneratorSettings
+    });
+  }
+  getLayerInfoByID(layerIDOrParams, options) {
+    const layerID = typeof layerIDOrParams === "number" ? layerIDOrParams : layerIDOrParams.layerID;
+    const resolvedOptions = typeof layerIDOrParams === "number" ? options : layerIDOrParams.options;
+    if (layerID == null) throw new Error("Invalid layerID");
+    const params = {
+      layerID,
+      getChildren: resolvedOptions?.getChildren
+    };
+    return this.plugin.jsx.execute("Layer/getLayerInfo", params);
+  }
+  getLayerInfoByIndex(layerIndexOrParams, options) {
+    const layerIndex = typeof layerIndexOrParams === "number" ? layerIndexOrParams : layerIndexOrParams.layerIndex;
+    const resolvedOptions = typeof layerIndexOrParams === "number" ? options : layerIndexOrParams.options;
+    if (layerIndex == null) throw new Error("Invalid layerIndex");
+    const params = {
+      layerIndex,
+      getChildren: resolvedOptions?.getChildren
+    };
+    return this.plugin.jsx.execute("Layer/getLayerInfo", params);
+  }
+};
+_init3 = __decoratorStart(_a3);
+__decorateElement(_init3, 1, "getLayerInfo", _getLayerInfo_dec, LayerModule);
+__decorateElement(_init3, 1, "getLayerInfoByID", _getLayerInfoByID_dec, LayerModule);
+__decorateElement(_init3, 1, "getLayerInfoByIndex", _getLayerInfoByIndex_dec, LayerModule);
+__decoratorMetadata(_init3, LayerModule);
+
+// src/modules/image/index.ts
+var import_sharp = __toESM(require("sharp"));
+
+// src/utilis/pixmap.ts
+var Pixmap = class {
+  constructor(buffer) {
+    this.format = buffer.readUInt8(0);
+    this.width = buffer.readUInt32BE(1);
+    this.height = buffer.readUInt32BE(5);
+    this.rowBytes = buffer.readUInt32BE(9);
+    this.colorMode = buffer.readUInt8(13);
+    this.channelCount = buffer.readUInt8(14);
+    this.bitsPerChannel = buffer.readUInt8(15);
+    this.pixels = buffer.slice(16, 16 + this.width * this.height * this.channelCount);
+    this.bytesPerPixel = this.bitsPerChannel / 8 * this.channelCount;
+    this.padding = this.rowBytes - this.width * this.channelCount;
+    this.readChannel = this.getReadChannel(this.bitsPerChannel);
+    this._initGetPixelMethod(this.channelCount);
+  }
+  getReadChannel(bitsPerChannel) {
+    if (16 === bitsPerChannel) {
+      return Buffer.prototype.readUInt16BE;
+    }
+    if (8 === bitsPerChannel) {
+      return Buffer.prototype.readUInt8;
+    }
+    if (32 === bitsPerChannel) {
+      return Buffer.prototype.readUInt32BE;
+    }
+    throw new Error(`Unsupported pixmap bit depth: ${bitsPerChannel}`);
+  }
+  getPixel1(n) {
+    var pixel = this.getRawPixel(n);
+    var grey = this.readChannel.call(pixel, 0);
+    return {
+      r: grey,
+      g: grey,
+      b: grey,
+      a: 255
+    };
+  }
+  getPixel3(n) {
+    var pixel = this.getRawPixel(n);
+    return {
+      r: this.readChannel.call(pixel, 2),
+      g: this.readChannel.call(pixel, 1),
+      b: this.readChannel.call(pixel),
+      a: 255
+    };
+  }
+  getPixel4(n) {
+    var pixel = this.getRawPixel(n);
+    return {
+      r: this.readChannel.call(pixel, 1),
+      g: this.readChannel.call(pixel, 2),
+      b: this.readChannel.call(pixel, 3),
+      a: this.readChannel.call(pixel, 0)
+    };
+  }
+  _initGetPixelMethod(channelCount) {
+    if (channelCount === 4) {
+      this.getPixel = this.getPixel4;
+    }
+    if (channelCount === 3) {
+      this.getPixel = this.getPixel3;
+    }
+    if (channelCount === 1) {
+      this.getPixel = this.getPixel1;
+    }
+  }
+  getRawPixel(n) {
+    var i = n * this.bytesPerPixel;
+    return this.pixels.slice(i, i + this.bytesPerPixel);
+  }
+};
+
+// src/modules/image/index.ts
+var _exportDocumentWs_dec, _getPreviewWs_dec, _exportLayerWs_dec, _a4, _init4;
+var ImageModule = class extends (_a4 = BaseModule, _exportLayerWs_dec = [ws(ProtocolMethod.ImageExportLayer)], _getPreviewWs_dec = [ws(ProtocolMethod.ImageGetPreview)], _exportDocumentWs_dec = [ws(ProtocolMethod.ImageExportDocument)], _a4) {
+  constructor(plugin) {
+    super("image", plugin);
+    __runInitializers(_init4, 5, this);
+  }
+  /**
+   * Export a single layer as a PNG buffer plus its bounds and pixel
+   * dimensions. `settings` carries the `GetPixmapSettings` Photoshop accepts;
+   * the four `include*` flags default to `true` when unspecified (the fix over
+   * generator-core). `layerSpec` is required — the underlying jsx needs an
+   * explicit layer id or index range.
+   */
+  async exportImage(options) {
+    const { documentId, layerSpec, settings = {} } = options;
+    const resolvedDocId = this.resolveDocumentId(documentId);
+    const pixmap = await this.getPixmap(resolvedDocId, layerSpec, settings);
+    const buffer = await this.encodePng(pixmap);
+    return {
+      buffer,
+      bounds: pixmap.bounds,
+      width: pixmap.width,
+      height: pixmap.height
+    };
+  }
+  /**
+   * Export a downscaled preview of a single layer. The scale is computed so
+   * the longer edge lands near 300px; scaling is done by Photoshop via
+   * `scaleX/scaleY`, not by `sharp`. `includeClipped/ClipBase/Adjustors` are
+   * forced to `false` to fetch only the body layer's pixels. `layerSpec` is
+   * required (a layer id; the layer's `rect` drives the scale).
+   */
+  async getPreview(options) {
+    const { documentId, layerSpec } = options;
+    const resolvedDocId = this.resolveDocumentId(documentId);
+    const settings = {};
+    const layer = await this.plugin.modules.layer.getLayerInfoByID(layerSpec);
+    if (!layer?.rect) throw new Error("Invalid layer info for preview");
+    settings.includeClipped = false;
+    settings.includeClipBase = false;
+    settings.includeAdjustors = false;
+    const scale = getScale(layer.rect.width, layer.rect.height);
+    settings.scaleX = scale;
+    settings.scaleY = scale;
+    const pixmap = await this.getPixmap(resolvedDocId, layerSpec, settings);
+    const buffer = await this.encodePng(pixmap);
+    return {
+      buffer,
+      bounds: pixmap.bounds,
+      width: pixmap.width,
+      height: pixmap.height
+    };
+  }
+  /**
+   * Export the whole document (its current visibility state, flattened) as a PNG
+   * buffer plus bounds and pixel dimensions. Unlike `exportImage` (a single layer
+   * via the `Layer/getLayerPixmap` jsx protocol), this uses generator-core's
+   * built-in `getDocumentPixmap`, which returns an already-parsed `PsPixmap`.
+   * `documentId` defaults to the current document; `settings` carries the
+   * `GetPixmapSettings` Photoshop accepts (e.g. `scaleX`/`scaleY`).
+   */
+  async exportDocument(options) {
+    const documentId = this.resolveDocumentId(options.documentId);
+    const pixmap = await this.plugin.generator.getDocumentPixmap(
+      documentId,
+      options.settings ?? {}
+    );
+    const buffer = await this.encodePng(pixmap);
+    return {
+      buffer,
+      bounds: pixmap.bounds,
+      width: pixmap.width,
+      height: pixmap.height
+    };
+  }
+  async exportLayerWs(options) {
+    const result = await this.exportImage(options);
+    const name = this.plugin.cos ? await this.resolveLayerName(options.layerSpec) : void 0;
+    return this.toWsResult(result, { upload: true }, name);
+  }
+  async getPreviewWs(options) {
+    const result = await this.getPreview(options);
+    return this.toWsResult(result, { upload: false });
+  }
+  async exportDocumentWs(options) {
+    const result = await this.exportDocument(options);
+    const name = this.plugin.cos ? this.resolveDocumentName(options.documentId) : void 0;
+    return this.toWsResult(result, { upload: true }, name);
+  }
+  /**
+   * Turn a module-internal {@link ImageResult} (raw PNG `buffer`) into the
+   * wire-friendly {@link WsImageResult} (`data` string). With `upload` set and
+   * `plugin.cos` enabled, the buffer is uploaded and `data` is the signed URL;
+   * otherwise `data` is a `data:image/png;base64,...` URI. Both forms drop
+   * straight into an `<img src>`.
+   */
+  async toWsResult(result, opts, name) {
+    let data;
+    if (opts.upload && this.plugin.cos) {
+      data = await this.plugin.cos.uploadObject(result.buffer, name);
+    } else {
+      data = "data:image/png;base64," + Buffer.from(result.buffer).toString("base64");
+    }
+    return {
+      data,
+      bounds: result.bounds,
+      width: result.width,
+      height: result.height
+    };
+  }
+  /**
+   * Resolve a layer's name for the COS object key. A numeric `layerSpec` is
+   * looked up via the layer module; an index-range spec has no single name, so it
+   * falls back to "layers". Lookup failures degrade to `layer-{id}` rather than
+   * failing the export.
+   */
+  async resolveLayerName(layerSpec) {
+    if (typeof layerSpec !== "number") return "layers";
+    try {
+      const layer = await this.plugin.modules.layer.getLayerInfoByID(layerSpec);
+      return layer?.name || `layer-${layerSpec}`;
+    } catch {
+      return `layer-${layerSpec}`;
+    }
+  }
+  /**
+   * Resolve a document's name for the COS object key. Uses the current document's
+   * name when the target is the current document; otherwise falls back to
+   * `doc-{id}` rather than spending a jsx round-trip to name an off-screen doc.
+   */
+  resolveDocumentName(documentId) {
+    const resolvedId = this.resolveDocumentId(documentId);
+    const current = this.plugin.modules.document.currentDocument;
+    if (current && current.id === resolvedId && current.name) return current.name;
+    return `doc-${resolvedId}`;
+  }
+  /**
+   * Faithful port of LightAi `LayerManager.getPixmap` (index.ts:364-482).
+   * Builds the params (dropping generator-core's stray `settings.thread` and
+   * defaulting the four `include*` flags to `true`), opens the pixmap jsx over
+   * the progress channel, and resolves three native promises as the
+   * bounds/pixmap/iccProfile messages arrive. Once all expected messages are
+   * in, signals the channel to settle and constructs a `Pixmap`.
+   */
+  async getPixmap(documentId, layerSpec, settings) {
+    const params = {
+      documentId,
+      layerSpec,
+      compId: settings.compId,
+      compIndex: settings.compIndex,
+      inputRect: settings.inputRect,
+      outputRect: settings.outputRect,
+      scaleX: settings.scaleX || 1,
+      scaleY: settings.scaleY || 1,
+      bounds: true,
+      boundsOnly: settings.boundsOnly,
+      useJPGEncoding: settings.useJPGEncoding || "",
+      useSmartScaling: settings.useSmartScaling || false,
+      includeAncestorMasks: settings.includeAncestorMasks || false,
+      convertToWorkingRGBProfile: settings.convertToWorkingRGBProfile || false,
+      useICCProfile: settings.useICCProfile || "",
+      getICCProfileData: settings.getICCProfileData || false,
+      allowDither: settings.allowDither || false,
+      useColorSettingsDither: settings.useColorSettingsDither || false,
+      interpolationType: settings.interpolationType,
+      forceSmartPSDPixelScaling: settings.forceSmartPSDPixelScaling || false,
+      clipToDocumentBounds: settings.clipToDocumentBounds || false,
+      maxDimension: settings.maxDimension || 1e4,
+      clipBounds: settings.clipBounds,
+      includeAdjustors: settings.includeAdjustors !== void 0 ? settings.includeAdjustors : true,
+      includeChildren: settings.includeChildren !== void 0 ? settings.includeChildren : true,
+      includeClipBase: settings.includeClipBase !== void 0 ? settings.includeClipBase : true,
+      includeClipped: settings.includeClipped !== void 0 ? settings.includeClipped : true
+    };
+    const channel = this.plugin.jsx.openJSXFile("Layer/getLayerPixmap", params, true);
+    let jsResolve;
+    let jsReject;
+    const jsPromise = new Promise((res, rej) => {
+      jsResolve = res;
+      jsReject = rej;
+    });
+    let pixmapResolve;
+    let pixmapReject;
+    const pixmapPromise = new Promise((res, rej) => {
+      pixmapResolve = res;
+      pixmapReject = rej;
+    });
+    let profileResolve;
+    let profileReject;
+    const profilePromise = new Promise((res, rej) => {
+      profileResolve = res;
+      profileReject = rej;
+    });
+    channel.onProgress((message) => {
+      if (message.type === "javascript") {
+        if (message.value instanceof Object && Object.prototype.hasOwnProperty.call(message.value, "bounds")) {
+          jsResolve(message.value);
+        }
+      } else if (message.type === "pixmap") {
+        pixmapResolve(message.value);
+      } else if (message.type === "iccProfile") {
+        profileResolve(message.value);
+      }
+    });
+    channel.onFail((err) => {
+      jsReject(err);
+      pixmapReject(err);
+      profileReject(err);
+    });
+    if (params.boundsOnly) {
+      pixmapResolve(void 0);
+      profileResolve(void 0);
+    }
+    if (!params.getICCProfileData) {
+      profileResolve(void 0);
+    }
+    const [js, iccProfileBuffer, pixmapBuffer] = await Promise.all([
+      jsPromise,
+      profilePromise,
+      pixmapPromise
+    ]);
+    channel.resolve();
+    if (params.boundsOnly && js && js.bounds) {
+      return js;
+    }
+    if (js && js.bounds && pixmapBuffer) {
+      const pixmap = new Pixmap(pixmapBuffer);
+      pixmap.bounds = js.bounds;
+      if (iccProfileBuffer) {
+        pixmap.iccProfile = iccProfileBuffer;
+      }
+      return pixmap;
+    }
+    throw new Error(
+      `Unexpected response from PS in getLayerPixmap: js=${JSON.stringify(js)}, pixmap=${pixmapBuffer ? "truthy" : "falsy"}, iccExpected=${params.getICCProfileData}`
+    );
+  }
+  /**
+   * Resolve the document id: explicit override, else the document module's
+   * current document, else fail loud (matches LightAi's "No document opened").
+   */
+  resolveDocumentId(documentId) {
+    if (documentId !== void 0) return documentId;
+    const current = this.plugin.modules.document.currentDocument;
+    if (current) return current.id;
+    throw new Error("No document opened");
+  }
+  /**
+   * Convert a pixmap's raw pixels into a tightly-packed RGBA buffer. Handles both
+   * the single-layer protocol (`getLayerPixmap`: 4-channel, no row padding) and
+   * generator-core's `getDocumentPixmap` (which may return 3-channel pixmaps and
+   * rows padded to `rowBytes`). 4-channel is Photoshop's `[A,R,G,B]` layout;
+   * 3-channel is `[R,G,B]` and gets an opaque alpha. Rows are walked by
+   * `rowBytes` so any per-row padding is skipped rather than misaligning the image.
+   */
+  parseRawPixels(pixmap) {
+    const { width, height, channelCount, pixels } = pixmap;
+    if (channelCount !== 3 && channelCount !== 4) {
+      throw new Error(`Unsupported channelCount: ${channelCount}`);
+    }
+    const rowBytes = pixmap.rowBytes && pixmap.rowBytes >= width * channelCount ? pixmap.rowBytes : width * channelCount;
+    const output = Buffer.allocUnsafe(width * height * 4);
+    let o = 0;
+    for (let y = 0; y < height; y++) {
+      let p = y * rowBytes;
+      for (let x = 0; x < width; x++) {
+        if (channelCount === 4) {
+          output[o++] = pixels.readUInt8(p + 1);
+          output[o++] = pixels.readUInt8(p + 2);
+          output[o++] = pixels.readUInt8(p + 3);
+          output[o++] = pixels.readUInt8(p);
+        } else {
+          output[o++] = pixels.readUInt8(p);
+          output[o++] = pixels.readUInt8(p + 1);
+          output[o++] = pixels.readUInt8(p + 2);
+          output[o++] = 255;
+        }
+        p += channelCount;
+      }
+    }
+    return output;
+  }
+  async encodePng(pixmap) {
+    const rgba = this.parseRawPixels(pixmap);
+    return (0, import_sharp.default)(rgba, {
+      raw: {
+        width: pixmap.width,
+        height: pixmap.height,
+        channels: 4
+      }
+    }).ensureAlpha().png().toBuffer();
+  }
+};
+_init4 = __decoratorStart(_a4);
+__decorateElement(_init4, 1, "exportLayerWs", _exportLayerWs_dec, ImageModule);
+__decorateElement(_init4, 1, "getPreviewWs", _getPreviewWs_dec, ImageModule);
+__decorateElement(_init4, 1, "exportDocumentWs", _exportDocumentWs_dec, ImageModule);
+__decoratorMetadata(_init4, ImageModule);
+var getScale = (width, height) => {
+  const xScale = Math.floor(width / 300) || 1;
+  const yScale = Math.floor(height / 300) || 1;
+  return 1 / Math.min(xScale, yScale);
+};
+
+// src/modules/index.ts
+var MODULES = {
+  layer: LayerModule,
+  document: DocumentModule,
+  action: ActionModule,
+  image: ImageModule
+};
+
+// src/services/cos.ts
+var import_cos_nodejs_sdk_v5 = __toESM(require("cos-nodejs-sdk-v5"));
+var import_node_path3 = require("path");
+var DEFAULT_KEY_PREFIX = "ps-bridge/exports";
+var DEFAULT_URL_EXPIRES_SECONDS = 31536e4;
+var MAX_NAME_LENGTH = 64;
+var CosService = class _CosService {
+  constructor(config, logger) {
+    this.config = config;
+    this.logger = logger;
+    this.cos = new import_cos_nodejs_sdk_v5.default({ SecretId: config.secretId, SecretKey: config.secretKey });
+  }
+  /**
+   * Build a CosService from the environment, or return undefined when COS is not
+   * configured. All four `PS_BRIDGE_COS_SECRET_ID/SECRET_KEY/BUCKET/REGION` must be
+   * present and non-empty — a missing field means "not enabled", decided once at
+   * startup rather than failing loudly on the first upload.
+   */
+  static fromEnv(logger) {
+    const secretId = process.env.PS_BRIDGE_COS_SECRET_ID?.trim();
+    const secretKey = process.env.PS_BRIDGE_COS_SECRET_KEY?.trim();
+    const bucket = process.env.PS_BRIDGE_COS_BUCKET?.trim();
+    const region = process.env.PS_BRIDGE_COS_REGION?.trim();
+    if (!secretId || !secretKey || !bucket || !region) return void 0;
+    const keyPrefix = process.env.PS_BRIDGE_COS_KEY_PREFIX?.trim() || DEFAULT_KEY_PREFIX;
+    const expiresRaw = Number(process.env.PS_BRIDGE_COS_URL_EXPIRES);
+    const urlExpires = Number.isFinite(expiresRaw) && expiresRaw > 0 ? expiresRaw : DEFAULT_URL_EXPIRES_SECONDS;
+    return new _CosService({ secretId, secretKey, bucket, region, keyPrefix, urlExpires }, logger);
+  }
+  async uploadObject(data, name) {
+    const key = this.buildKey(name, ".png");
+    await this.putObject(key, Buffer.from(data));
+    return this.signedUrl(key);
+  }
+  async uploadFile(dir, name) {
+    const key = this.buildKey(name, (0, import_node_path3.extname)(dir));
+    await this.putFile(key, dir);
+    return this.signedUrl(key);
+  }
+  /**
+   * Compose the object key `{keyPrefix}/{name}-{ts}{ext}` (keyPrefix is env-
+   * configurable, default `ps-bridge/exports`). `name` (a layer/document name) is
+   * kept verbatim including non-ASCII (e.g. Chinese); only path separators and
+   * whitespace are replaced — they would nest the key or break the URL — and the
+   * label is length-capped. Uniqueness rides on the timestamp, not the label.
+   */
+  buildKey(name, ext) {
+    const label = this.sanitizeName(name ?? "image");
+    return `${this.config.keyPrefix}/${label}-${Date.now()}${ext}`;
+  }
+  sanitizeName(name) {
+    const cleaned = name.replace(/[/\\\s]+/g, "_").replace(/^_+/, "").slice(0, MAX_NAME_LENGTH);
+    return cleaned || "image";
+  }
+  putObject(key, body) {
+    return new Promise((resolve2, reject) => {
+      this.cos.putObject(
+        { Bucket: this.config.bucket, Region: this.config.region, Key: key, Body: body },
+        (err, data) => {
+          if (err) return reject(new Error(err.message ?? String(err)));
+          if (data.statusCode !== 200) {
+            return reject(new Error(`COS upload failed: status ${data.statusCode}`));
+          }
+          this.logger.info(`CosService uploaded object ${key}`);
+          resolve2();
+        }
+      );
+    });
+  }
+  putFile(key, filePath) {
+    return new Promise((resolve2, reject) => {
+      this.cos.uploadFile(
+        { Bucket: this.config.bucket, Region: this.config.region, Key: key, FilePath: filePath },
+        (err) => {
+          if (err) return reject(new Error(err.message ?? String(err)));
+          this.logger.info(`CosService uploaded file ${key}`);
+          resolve2();
+        }
+      );
+    });
+  }
+  signedUrl(key) {
+    return new Promise((resolve2, reject) => {
+      this.cos.getObjectUrl(
+        {
+          Bucket: this.config.bucket,
+          Region: this.config.region,
+          Key: key,
+          Sign: true,
+          Expires: this.config.urlExpires
+        },
+        (err, data) => {
+          if (err) return reject(err instanceof Error ? err : new Error(String(err)));
+          resolve2(data.Url);
+        }
+      );
+    });
+  }
+};
+
+// src/plugin.ts
+var MENU_ID = "psGeneratorBridge";
+var MENU_LABEL = "PS Generator Bridge: Server";
+var MENU_EVENT = "generatorMenuChanged";
+var PsBridgeHost = class _PsBridgeHost {
+  constructor(generator, config, logger, overrides) {
+    this.generator = generator;
+    this.config = config;
+    this.logger = logger;
+    this.plugins = [];
+    this.modules = {
+      layer: new MODULES.layer(this),
+      document: new MODULES.document(this),
+      action: new MODULES.action(this),
+      image: new MODULES.image(this)
+    };
+    this._jsx = new JsxRunner(generator, logger, overrides?.polyfillsDir);
+    this._events = new EventManager(generator);
+    this.cos = CosService.fromEnv(logger);
+    logger.info(this.cos ? "CosService enabled" : "CosService disabled (env incomplete)");
+  }
+  /** Run packaged jsx by name (ADR 0008). Used by modules and other server callers. */
+  get jsx() {
+    return this._jsx;
+  }
+  /** Photoshop event subscriptions owned by the host. */
+  get events() {
+    return this._events;
+  }
+  /**
+   * Build the host contract for one plugin (RFC 0005). A shallow view that shares
+   * the host's `modules` and `events` (both global-singleton semantics — they do
+   * not split per plugin) but swaps in a `jsx` scoped to `<pluginDir>/jsx`, so the
+   * plugin's `jsx.execute("x")` resolves to its own files while `executeBuiltin`
+   * still reaches the built-in tree. Passed to `loadPlugins` as the `hostFor`
+   * factory; the plugin never sees the concrete `PsBridgeHost`.
+   */
+  hostFor(pluginDir) {
+    return {
+      modules: this.modules,
+      events: this._events,
+      jsx: this._jsx.forPlugin((0, import_node_path4.join)(pluginDir, "jsx")),
+      cos: this.cos
+    };
+  }
+  /** Entry point: construct the host and run its async initialization. */
+  static async init(generator, config, logger, overrides) {
+    const host = new _PsBridgeHost(generator, config, logger, overrides);
+    await host.onInit();
+    return host;
+  }
+  async onInit() {
+    this.logger.info(`${PLUGIN_NAME} v${PLUGIN_VERSION} initializing`);
+    this.createMenuItem();
+    const port = this.config.port ?? portFromEnv(this.logger) ?? DEFAULT_PORT;
+    const server = createServer({
+      port,
+      generator: this.generator,
+      jsx: this._jsx,
+      events: this._events,
+      logger: this.logger
+    });
+    this.server = server;
+    const pluginsDir = this.config.pluginsDir ?? process.env.PS_BRIDGE_PLUGINS_DIR ?? (0, import_node_path4.join)(__dirname, "..", "plugins");
+    const { loaded, skipped } = await loadPlugins({
+      pluginsDir,
+      hostFor: (pluginDir) => this.hostFor(pluginDir),
+      knownIds: /* @__PURE__ */ new Set(),
+      logger: this.logger
+    });
+    for (const s of skipped) this.logger.warn(`plugin skipped: ${s.path} \u2014 ${s.reason}`);
+    this.plugins = loaded.map((l) => l.plugin);
+    for (const plugin of this.plugins) {
+      server.pluginManager.register(plugin);
+    }
+    server.registry.reservedSegments = new Set(server.pluginManager.ids);
+    for (const module2 of Object.values(this.modules)) {
+      bootstrap(module2, server.registry);
+    }
+    await this._jsx.init();
+    await server.listen();
+    this.logger.info(`${PLUGIN_NAME} initialized`);
+  }
+  createMenuItem() {
+    this.generator.addMenuItem(MENU_ID, MENU_LABEL, true, false);
+    this.generator.onPhotoshopEvent(
+      MENU_EVENT,
+      (event) => this.handleMenuClicked(event)
+    );
+    this.logger.debug(`menu item registered: ${MENU_ID}`);
+  }
+  // "generatorMenuChanged" fires for *every* plugin's menu, so we must filter to
+  // our own id before acting.
+  handleMenuClicked(event) {
+    if (event?.generatorMenuChanged?.name !== MENU_ID) return;
+    const port = this.server?.port ?? this.config.port ?? DEFAULT_PORT;
+    this.generator.alert(
+      `${PLUGIN_NAME} v${PLUGIN_VERSION} \u2014 listening on ws://127.0.0.1:${port}/ws`
+    );
+  }
+  /** Stop the WebSocket service (used by tests; PS teardown is process exit). */
+  async close() {
+    await this.server?.close();
+    this.server = void 0;
+  }
+};
+function portFromEnv(logger) {
+  const raw = process.env.PS_BRIDGE_PORT;
+  if (!raw) return void 0;
+  const port = Number(raw);
+  if (Number.isInteger(port) && port > 0 && port <= 65535) return port;
+  logger.warn(`ignoring invalid PS_BRIDGE_PORT: ${raw}`);
+  return void 0;
+}
+
+// src/utilis/logger.ts
+function format(args) {
+  return args.map((arg) => {
+    if (arg instanceof Error) return `${arg.name}: ${arg.message}`;
+    if (typeof arg === "object" && arg !== null) return JSON.stringify(arg);
+    return String(arg);
+  }).join(" ");
+}
+function createLogger(name = "ps-bridge") {
+  const emit = (level, message, args) => {
+    const line = `[${level}] ${name}: ${message}${args.length ? ` ${format(args)}` : ""}`;
+    if (level === "error") console.error(line);
+    else if (level === "warn") console.warn(line);
+    else console.log(line);
+  };
+  return {
+    debug: (message, ...args) => emit("debug", message, args),
+    info: (message, ...args) => emit("info", message, args),
+    warn: (message, ...args) => emit("warn", message, args),
+    error: (message, ...args) => emit("error", message, args)
+  };
+}
+
+// src/index.ts
+function init(generator, config) {
+  const logger = createLogger();
+  void PsBridgeHost.init(generator, config ?? {}, logger).catch(
+    (error) => logger.error("plugin init failed", error)
+  );
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  JsxRunner,
+  PsBridgeHost,
+  init
+});
+//# sourceMappingURL=index.js.map