@ps-generator-bridge/sdk 0.1.0

package/dist/plugin.cjs

@@ -0,0 +1,915 @@
+'use strict';
+
+// 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})`);
+}
+
+// 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}`;
+  }
+};
+
+// 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`);
+  }
+  /**
+   * 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);
+  }
+  /**
+   * 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()`);
+  }
+};
+/** BlendMode code -> enum-name map (all 27 members, plus newer ones). */
+_PhotoshopLayer._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"
+};
+// --- ArtLayer-only properties -------------------------------------------
+/** LayerKind code -> enum-name map. */
+_PhotoshopLayer._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"
+};
+var PhotoshopLayer = _PhotoshopLayer;
+
+// 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})`);
+  }
+};
+
+// 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)
+      ])
+    );
+  }
+};
+
+// 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);
+  }
+};
+
+// 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()`);
+  }
+};
+
+// 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/photoshop/enums.ts
+var SaveOptions = {
+  /** Do not save changes. */
+  DONOTSAVECHANGES: "SaveOptions.DONOTSAVECHANGES",
+  /** Prompt the user. */
+  PROMPTTOSAVECHANGES: "SaveOptions.PROMPTTOSAVECHANGES",
+  /** Save changes. */
+  SAVECHANGES: "SaveOptions.SAVECHANGES"
+};
+var LayerKind = {
+  NORMAL: "LayerKind.NORMAL",
+  TEXT: "LayerKind.TEXT",
+  SMARTOBJECT: "LayerKind.SMARTOBJECT",
+  SOLIDFILL: "LayerKind.SOLIDFILL",
+  /**
+   * @remarks In `enums.d.ts`, GRADIENTFILL=4 and PATTERNFILL=4 share a value
+   * (an Adobe enum conflict); a kind of 4 always maps back to GRADIENTFILL and
+   * the two cannot be told apart at runtime (disambiguate by layer name etc.).
+   */
+  GRADIENTFILL: "LayerKind.GRADIENTFILL",
+  PATTERNFILL: "LayerKind.PATTERNFILL",
+  LEVELS: "LayerKind.LEVELS",
+  CURVES: "LayerKind.CURVES",
+  BRIGHTNESSCONTRAST: "LayerKind.BRIGHTNESSCONTRAST",
+  HUESATURATION: "LayerKind.HUESATURATION",
+  COLORBALANCE: "LayerKind.COLORBALANCE",
+  INVERSION: "LayerKind.INVERSION",
+  POSTERIZE: "LayerKind.POSTERIZE",
+  THRESHOLD: "LayerKind.THRESHOLD",
+  EXPOSURE: "LayerKind.EXPOSURE",
+  VIBRANCE: "LayerKind.VIBRANCE",
+  VIDEO: "LayerKind.VIDEO",
+  LAYER3D: "LayerKind.LAYER3D",
+  BLACKANDWHITE: "LayerKind.BLACKANDWHITE",
+  CHANNELMIXER: "LayerKind.CHANNELMIXER",
+  GRADIENTMAP: "LayerKind.GRADIENTMAP",
+  SELECTIVECOLOR: "LayerKind.SELECTIVECOLOR",
+  PHOTOFILTER: "LayerKind.PHOTOFILTER",
+  COLORLOOKUP: "LayerKind.COLORLOOKUP"
+};
+var BlendMode = {
+  NORMAL: "BlendMode.NORMAL",
+  DISSOLVE: "BlendMode.DISSOLVE",
+  DARKEN: "BlendMode.DARKEN",
+  MULTIPLY: "BlendMode.MULTIPLY",
+  COLORBURN: "BlendMode.COLORBURN",
+  LINEARBURN: "BlendMode.LINEARBURN",
+  DARKERCOLOR: "BlendMode.DARKERCOLOR",
+  LIGHTEN: "BlendMode.LIGHTEN",
+  SCREEN: "BlendMode.SCREEN",
+  COLORDODGE: "BlendMode.COLORDODGE",
+  LINEARDODGE: "BlendMode.LINEARDODGE",
+  LIGHTERCOLOR: "BlendMode.LIGHTERCOLOR",
+  OVERLAY: "BlendMode.OVERLAY",
+  SOFTLIGHT: "BlendMode.SOFTLIGHT",
+  HARDLIGHT: "BlendMode.HARDLIGHT",
+  VIVIDLIGHT: "BlendMode.VIVIDLIGHT",
+  LINEARLIGHT: "BlendMode.LINEARLIGHT",
+  PINLIGHT: "BlendMode.PINLIGHT",
+  HARDMIX: "BlendMode.HARDMIX",
+  DIFFERENCE: "BlendMode.DIFFERENCE",
+  EXCLUSION: "BlendMode.EXCLUSION",
+  SUBTRACT: "BlendMode.SUBTRACT",
+  DIVIDE: "BlendMode.DIVIDE",
+  HUE: "BlendMode.HUE",
+  SATURATION: "BlendMode.SATURATION",
+  COLORBLEND: "BlendMode.COLORBLEND",
+  LUMINOSITY: "BlendMode.LUMINOSITY",
+  PASSTHROUGH: "BlendMode.PASSTHROUGH"
+};
+var ElementPlacement = {
+  PLACEATBEGINNING: "ElementPlacement.PLACEATBEGINNING",
+  PLACEINSIDE: "ElementPlacement.PLACEINSIDE",
+  PLACEBEFORE: "ElementPlacement.PLACEBEFORE",
+  PLACEAFTER: "ElementPlacement.PLACEAFTER",
+  PLACEATEND: "ElementPlacement.PLACEATEND"
+};
+var AnchorPosition = {
+  TOPLEFT: "AnchorPosition.TOPLEFT",
+  TOPCENTER: "AnchorPosition.TOPCENTER",
+  TOPRIGHT: "AnchorPosition.TOPRIGHT",
+  MIDDLELEFT: "AnchorPosition.MIDDLELEFT",
+  MIDDLECENTER: "AnchorPosition.MIDDLECENTER",
+  MIDDLERIGHT: "AnchorPosition.MIDDLERIGHT",
+  BOTTOMLEFT: "AnchorPosition.BOTTOMLEFT",
+  BOTTOMCENTER: "AnchorPosition.BOTTOMCENTER",
+  BOTTOMRIGHT: "AnchorPosition.BOTTOMRIGHT"
+};
+var DocumentMode = {
+  BITMAP: "DocumentMode.BITMAP",
+  GRAYSCALE: "DocumentMode.GRAYSCALE",
+  RGB: "DocumentMode.RGB",
+  CMYK: "DocumentMode.CMYK",
+  LAB: "DocumentMode.LAB",
+  INDEXEDCOLOR: "DocumentMode.INDEXEDCOLOR",
+  MULTICHANNEL: "DocumentMode.MULTICHANNEL",
+  DUOTONE: "DocumentMode.DUOTONE"
+};
+var SelectionType = {
+  REPLACE: "SelectionType.REPLACE",
+  EXTEND: "SelectionType.EXTEND",
+  DIMINISH: "SelectionType.DIMINISH",
+  INTERSECT: "SelectionType.INTERSECT"
+};
+
+// 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]);
+}
+
+// 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 api(pathOrRoute) {
+  const route = typeof pathOrRoute === "string" ? { method: "GET", url: pathOrRoute } : { method: pathOrRoute.method ?? "GET", url: pathOrRoute.url };
+  return function(_value, context) {
+    pushHandler(context.metadata, {
+      kind: "api",
+      method: route.method,
+      url: route.url,
+      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 });
+    }
+  }
+}
+
+exports.AnchorPosition = AnchorPosition;
+exports.BasePlugin = BasePlugin;
+exports.BlendMode = BlendMode;
+exports.DocumentMode = DocumentMode;
+exports.ElementPlacement = ElementPlacement;
+exports.LayerKind = LayerKind;
+exports.SaveOptions = SaveOptions;
+exports.SelectionType = SelectionType;
+exports.api = api;
+exports.bootstrap = bootstrap;
+exports.isBasePluginClass = isBasePluginClass;
+exports.ws = ws;
+//# sourceMappingURL=plugin.cjs.map
+//# sourceMappingURL=plugin.cjs.map