@pixerate/editor 0.110.0 → 0.112.0

package/dist/image-editor/index.js

@@ -17,8 +17,10 @@ import {
   D50,
   D65,
   DEFAULT_ADJUSTMENTS_VALUES,
+  DEFAULT_AUTO_LEADING,
   DEFAULT_DEPTH_MASK_VALUES,
   DEFAULT_MITER_LIMIT,
+  DEFAULT_TEXT_STYLE,
   DEFAULT_TRANSFORM_VALUES,
   DEVELOP_FILTER_ID,
   EMPTY_DISTANCE,
@@ -35,6 +37,7 @@ import {
   MAX_KELVIN,
   MIN_KELVIN,
   MIRED_PER_TEMPERATURE_UNIT,
+  PARAGRAPH_STYLE_FIELDS,
   PATTERN_BLOCK_KEYS,
   PSD_BLEND_KEYS,
   PsdError,
@@ -44,6 +47,9 @@ import {
   SHAPE_RENDER_MARGIN,
   SMART_RENDER_MARGIN,
   SUPPORTED_ADJUSTMENT_KEYS,
+  TEXT_ALIGNS,
+  TEXT_RENDER_MARGIN,
+  TEXT_STYLE_FIELDS,
   TINT_SCALE,
   TONE_LUT_SIZE,
   TRANSFORM_ANCHORS,
@@ -64,6 +70,7 @@ import {
   annotationLayerName,
   annotationOfLayer,
   annotationOfShape,
+  annotationOfType,
   applyAdjustmentLayers,
   applyAdjustments,
   applyBoxBlur,
@@ -84,6 +91,7 @@ import {
   buildToneLut,
   calculateCropDrag,
   canvasToImagePoint,
+  caretAt,
   clampCropToImage,
   colorBalanceChannel,
   combineSelections,
@@ -100,6 +108,7 @@ import {
   createAdjustmentLayer,
   createSelectionMask,
   createShapeLayer,
+  createTypeLayer,
   curveLutFromLevels,
   decodeLayerChannel,
   decodeLayerMask,
@@ -131,8 +140,11 @@ import {
   exportPsd,
   featherCoverage,
   filterMaskCoverage,
+  fitParagraphRuns,
+  fitRuns,
   flattenPath,
   flipCorners,
+  fontOf,
   fullSelection,
   geometryHomography,
   getAnnotationBounds,
@@ -183,6 +195,7 @@ import {
   layerTree,
   layerTypeLabel,
   layersFromLegacy,
+  layoutText,
   legacyAdjustmentLayer,
   legacyMaskOf,
   legacyView,
@@ -215,9 +228,11 @@ import {
   normalizeShapeStroke,
   normalizeSmartFilter,
   normalizeSubpaths,
+  normalizeText,
   offsetLayer,
   offsetShape,
   offsetSmartObject,
+  paragraphRanges,
   parseAdjustmentBlock,
   parseBlend,
   parseCssColor,
@@ -226,6 +241,8 @@ import {
   parsePatternBlock,
   parseSelectionMode,
   parseVersionedDescriptor,
+  patchParagraphStyle,
+  patchTextStyle,
   photoFilterMatrix,
   pixelLayerBounds,
   pixelLayers,
@@ -256,16 +273,21 @@ import {
   renderShape,
   renderShapeRect,
   renderSmartObject,
+  renderText,
   replaceContents,
+  replaceTextRange,
   requireLayer,
   requireOperation,
   requireShapeLayer,
   requireSmartObject,
+  requireTypeLayer,
   requireUnlocked,
   rerender,
   rerenderShape,
+  rerenderText,
   resizeSelection,
   resolveExternalAssets,
+  restyleRange,
   rgbToGray,
   rgbToHsl,
   runLayerFilters,
@@ -301,16 +323,28 @@ import {
   smartContentsFile,
   smartObjectLayers,
   smoothCoverage,
+  spliceRuns,
   srgbToLinear,
+  styleAt,
   tempTintToXy,
   temperatureToKelvin,
+  textIndexAt,
+  textMatrix,
+  textOutlines,
+  textRange,
+  toTextSpace,
   toneCurve,
   toneLuts,
   transformHomography,
   transformMap,
   transformShapeComponents,
+  transformTypeLayer,
   transformedBox,
   transformedPoint,
+  typeAsPixelLayer,
+  typeFrame,
+  typeFromAnnotation,
+  typeLayerName,
   ungroupLayer,
   unionRect,
   unprojectCanvasPoint,
@@ -319,6 +353,7 @@ import {
   updateLayerMaskProps,
   updateShapeLayer,
   updateSmartFilter,
+  updateTypeLayer,
   uvToXy,
   versionedDescriptorBytes,
   vibranceLinear,
@@ -334,7 +369,7 @@ import {
   writePsd,
   xyToTempTint,
   xyToUv
-} from "../chunk-DMRSJBJF.js";
+} from "../chunk-CZOXTEMN.js";
 import {
   DEFAULT_GLOBAL_LIGHT,
   DIRECT_GAUSSIAN_MAX_SIGMA,
@@ -506,12 +541,15 @@ import {
   WARP_STYLES,
   WARP_STYLE_LABELS,
   applyMatrix,
+  bezierToSubpaths,
   dragWarpMeshPoint,
   evalWarpMesh,
   identityWarpMesh,
+  invertMatrix,
   multiplyMatrices,
   pullWarpMesh,
   resizeWarpMesh,
+  rotateMatrix,
   roundSubpaths,
   translateMatrix,
   warpMeshColumns,
@@ -700,7 +738,7 @@ function needsLegacyBase(input) {
   if (hasResampledLegacyMask(stack.layers, canvas.width, canvas.height)) return true;
   return false;
 }
-var isPlainAnnotation = (l) => l.type === "annotation" ? l.opacity === 1 && l.blend === "normal" && !l.clipped && !l.mask : l.type === "shape" && Boolean(l.annotation) && l.opacity === 1 && l.blend === (l.annotation.blend ?? "normal") && !l.clipped && !l.mask && !l.effects && (l.fillOpacity ?? 1) === 1;
+var isPlainAnnotation = (l) => l.type === "annotation" ? l.opacity === 1 && l.blend === "normal" && !l.clipped && !l.mask : (l.type === "shape" || l.type === "type") && Boolean(l.annotation) && l.opacity === 1 && l.blend === (l.annotation.blend ?? "normal") && !l.clipped && !l.mask && !l.effects && (l.fillOpacity ?? 1) === 1;
 var overlayViews = /* @__PURE__ */ new WeakMap();
 function overlayView(l) {
   if (l.type === "annotation") return l;
@@ -716,7 +754,7 @@ function splitOverlayAnnotations(layers) {
   let i = layers.length;
   while (i > 0) {
     const l = layers[i - 1];
-    if ((l.type === "annotation" || l.type === "shape" && l.annotation) && (!l.visible || isPlainAnnotation(l))) i--;
+    if ((l.type === "annotation" || (l.type === "shape" || l.type === "type") && l.annotation) && (!l.visible || isPlainAnnotation(l))) i--;
     else break;
   }
   return {
@@ -1027,6 +1065,45 @@ var ImageEditorRenderer = class {
       }
       ctx.restore();
     }
+    if (options.textEdit) {
+      const t = options.textEdit;
+      ctx.save();
+      try {
+        const scr = (p) => projectImagePoint(p, projection);
+        const poly = (pts) => {
+          ctx.beginPath();
+          pts.map(scr).forEach((p, i) => i ? ctx.lineTo(p.x, p.y) : ctx.moveTo(p.x, p.y));
+          ctx.closePath();
+        };
+        if (t.frame) {
+          poly(t.frame);
+          ctx.setLineDash([4, 3]);
+          ctx.lineWidth = 1;
+          ctx.strokeStyle = "rgba(99,102,241,0.9)";
+          ctx.stroke();
+          ctx.setLineDash([]);
+        }
+        ctx.fillStyle = "rgba(99,102,241,0.35)";
+        for (const q of t.selection) {
+          poly(q);
+          ctx.fill();
+        }
+        if (t.caret) {
+          const [a, b] = t.caret.map(scr);
+          ctx.beginPath();
+          ctx.moveTo(a.x, a.y);
+          ctx.lineTo(b.x, b.y);
+          ctx.lineWidth = 3;
+          ctx.strokeStyle = "#ffffff";
+          ctx.stroke();
+          ctx.lineWidth = 1.5;
+          ctx.strokeStyle = "#111827";
+          ctx.stroke();
+        }
+      } catch {
+      }
+      ctx.restore();
+    }
     if (options.freeTransform) {
       const t = options.freeTransform;
       ctx.save();
@@ -2441,6 +2518,159 @@ function refineSelection(pixels, mask, params = {}) {
   return createSelectionMask(mask.width, mask.height, out);
 }
 
+// src/image-editor/layers/text-shapers.ts
+var GENERIC = /* @__PURE__ */ new Set(["serif", "sans-serif", "monospace", "cursive", "fantasy", "system-ui", "ui-serif", "ui-sans-serif", "ui-monospace", "ui-rounded", "math", "emoji", "fangsong"]);
+function cssFontFamily(family) {
+  const f = family.trim();
+  if (GENERIC.has(f.toLowerCase()) || f.includes(",") || /^["']/.test(f)) return f;
+  return /^[A-Za-z_-][\w -]*$/.test(f) && !/\s{2}/.test(f) ? f : `"${f.replace(/"/g, '\\"')}"`;
+}
+function cssFont(font, family = font.family) {
+  return `${font.italic ? "italic " : ""}${font.weight} ${font.size}px ${cssFontFamily(family)}`;
+}
+function createCanvasTextShaper(options = {}) {
+  const make = options.createCanvas ?? ((w, h) => {
+    if (typeof OffscreenCanvas !== "undefined") return new OffscreenCanvas(w, h);
+    if (typeof document !== "undefined") {
+      const c = document.createElement("canvas");
+      c.width = w;
+      c.height = h;
+      return c;
+    }
+    return null;
+  });
+  const canvas = make(1, 1);
+  const ctx = canvas?.getContext("2d");
+  if (!ctx || typeof ctx.measureText !== "function") return null;
+  const fallback = options.fallbackFamily ?? "sans-serif";
+  const available = /* @__PURE__ */ new Map();
+  const widths = /* @__PURE__ */ new Map();
+  const metrics = /* @__PURE__ */ new Map();
+  const probe = "mmmmmmmmmmlli1WQ@#";
+  const width = (font, text) => {
+    ctx.font = font;
+    return ctx.measureText(text).width;
+  };
+  const isAvailable = (family) => {
+    const f = family.trim();
+    if (GENERIC.has(f.toLowerCase()) || f.includes(",")) return true;
+    let hit = available.get(f);
+    if (hit === void 0) {
+      const q = cssFontFamily(f);
+      hit = width(`72px ${q}, monospace`, probe) !== width("72px monospace", probe) || width(`72px ${q}, serif`, probe) !== width("72px serif", probe);
+      available.set(f, hit);
+    }
+    return hit;
+  };
+  return {
+    id: "canvas",
+    resolve(font) {
+      const ok = isAvailable(font.family);
+      return { family: ok ? font.family : fallback, available: ok };
+    },
+    metrics(font) {
+      const key = cssFont(font);
+      let m = metrics.get(key);
+      if (!m) {
+        ctx.font = key;
+        ctx.textBaseline = "alphabetic";
+        const t = ctx.measureText("Hg");
+        const ascent = t.emHeightAscent ?? t.fontBoundingBoxAscent ?? font.size * 0.8;
+        const descent = t.emHeightDescent ?? t.fontBoundingBoxDescent ?? font.size * 0.2;
+        m = { ascent: Number.isFinite(ascent) ? ascent : font.size * 0.8, descent: Number.isFinite(descent) ? descent : font.size * 0.2 };
+        metrics.set(key, m);
+      }
+      return m;
+    },
+    measure(text, font) {
+      const key = `${cssFont(font)}|${text}`;
+      let w = widths.get(key);
+      if (!w) {
+        ctx.font = cssFont(font);
+        w = [0];
+        for (let i = 1; i <= text.length; i++) w.push(ctx.measureText(text.slice(0, i)).width);
+        if (widths.size > 2e3) widths.clear();
+        widths.set(key, w);
+      }
+      return w;
+    },
+    draw(target, text, font, x, y) {
+      target.font = cssFont(font);
+      target.textBaseline = "alphabetic";
+      target.textAlign = "left";
+      target.fillText(text, x, y);
+    },
+    families() {
+      const out = /* @__PURE__ */ new Set(["sans-serif", "serif", "monospace"]);
+      const fonts = typeof document !== "undefined" ? document.fonts : void 0;
+      if (fonts && typeof fonts.forEach === "function") fonts.forEach((f) => out.add(f.family.replace(/^["']|["']$/g, "")));
+      return [...out];
+    }
+  };
+}
+function createOutlineTextShaper(fonts, options = {}) {
+  if (!fonts.length) throw new Error("createOutlineTextShaper needs at least one font.");
+  const entries = fonts.map((f) => {
+    const e = "face" in f ? f : { face: f };
+    const names = e.face.names;
+    const family = e.family ?? names?.fontFamily?.en ?? Object.values(names?.fontFamily ?? {})[0] ?? "Font";
+    const weight = e.weight ?? e.face.tables?.os2?.usWeightClass ?? 400;
+    const italic = e.italic ?? Boolean((e.face.tables?.os2?.fsSelection ?? 0) & 1);
+    const postScript = names?.postScriptName?.en ?? Object.values(names?.postScriptName ?? {})[0];
+    return { face: e.face, family, key: family.toLowerCase(), weight, italic, postScript };
+  });
+  const fallbackKey = (options.fallback ?? entries[0].family).toLowerCase();
+  const pick2 = (font) => {
+    if (font.postScriptName) {
+      const exact = entries.find((e) => e.postScript === font.postScriptName);
+      if (exact) return { entry: exact, available: true };
+    }
+    const key = font.family.trim().toLowerCase();
+    let pool = entries.filter((e) => e.key === key);
+    const available = pool.length > 0;
+    if (!available) pool = entries.filter((e) => e.key === fallbackKey);
+    if (!pool.length) pool = entries;
+    const styled = pool.filter((e) => e.italic === font.italic);
+    const list = styled.length ? styled : pool;
+    const entry = list.reduce((best, e) => Math.abs(e.weight - font.weight) < Math.abs(best.weight - font.weight) ? e : best);
+    return { entry, available };
+  };
+  const toPath = (cmds) => {
+    const out = [];
+    for (const c of cmds) {
+      if (c.type === "M" || c.type === "L") out.push({ type: c.type, x: c.x, y: c.y });
+      else if (c.type === "C") out.push({ type: "C", x1: c.x1, y1: c.y1, x2: c.x2, y2: c.y2, x: c.x, y: c.y });
+      else if (c.type === "Q") out.push({ type: "Q", x1: c.x1, y1: c.y1, x: c.x, y: c.y });
+      else out.push({ type: "Z" });
+    }
+    return out;
+  };
+  return {
+    id: options.id ?? `outline:${entries.map((e) => `${e.family}/${e.weight}${e.italic ? "i" : ""}`).join(",")}`,
+    resolve(font) {
+      const { entry, available } = pick2(font);
+      return { family: entry.family, available };
+    },
+    metrics(font) {
+      const { face } = pick2(font).entry;
+      const k = font.size / face.unitsPerEm;
+      return { ascent: face.ascender * k, descent: -face.descender * k };
+    },
+    measure(text, font) {
+      const { face } = pick2(font).entry;
+      const out = [0];
+      for (let i = 1; i <= text.length; i++) out.push(face.getAdvanceWidth(text.slice(0, i), font.size, { kerning: true }));
+      return out;
+    },
+    outline(text, font, x, y) {
+      return toPath(pick2(font).entry.face.getPath(text, x, y, font.size, { kerning: true }).commands);
+    },
+    families() {
+      return [...new Set(entries.map((e) => e.family))];
+    }
+  };
+}
+
 // src/image-editor/free-transform.ts
 var FREE_TRANSFORM_CONTENTS = ["auto", "layer", "selection", "selection-copy", "selection-outline"];
 var fail = (message) => {
@@ -2512,7 +2742,7 @@ var FreeTransformSession = class {
     }
     const targetId = init.layerId ?? host.activeLayerId();
     const target = targetId && content !== "selection-outline" ? findLayer(host.layers(), targetId)?.layer : void 0;
-    const smartTarget = (target?.type === "smart" || target?.type === "shape") && (init.channel ?? (target.id === host.activeLayerId() ? host.activeTarget() : "pixels")) !== "mask";
+    const smartTarget = (target?.type === "smart" || target?.type === "shape" || target?.type === "type") && (init.channel ?? (target.id === host.activeLayerId() ? host.activeTarget() : "pixels")) !== "mask";
     if (content === "auto") content = selected && !smartTarget ? "selection" : "layer";
     this.content = content;
     if (content !== "layer" && !selected) fail(`Nothing is selected; ${content} needs a selection. Select first, or use content layer.`);
@@ -2539,7 +2769,7 @@ var FreeTransformSession = class {
       const linked = mask?.linked !== false;
       const maskAlone = channel === "mask" && (!linked || layer.type !== "pixel");
       if (channel === "mask" && !mask) fail(layer.mask?.source ? `Layer "${layer.name || id}" has a depth mask, which is generated, not transformed.` : `Layer "${layer.name || id}" has no mask to transform; add one with add_layer_mask, or transform its pixels.`);
-      if (!maskAlone && layer.type !== "pixel" && layer.type !== "smart" && layer.type !== "shape") fail(`Layer "${layer.name || id}" is a ${layer.type} layer; Free Transform works on pixel, shape and smart object layers, layer masks (channel mask) and selections.`);
+      if (!maskAlone && layer.type !== "pixel" && layer.type !== "smart" && layer.type !== "shape" && layer.type !== "type") fail(`Layer "${layer.name || id}" is a ${layer.type} layer; Free Transform works on pixel, shape, type and smart object layers, layer masks (channel mask) and selections.`);
       if (!layer.visible && content !== "selection-copy") fail(`Layer "${layer.name || id}" is hidden; show it before you transform it.`);
       if (content !== "selection-copy") {
         requireUnlocked(layer, "position", "transform it");
@@ -2561,6 +2791,26 @@ var FreeTransformSession = class {
         this.shown = this.startLayers;
         return;
       }
+      if (layer.type === "type" && !maskAlone) {
+        if (content !== "layer") fail(`Layer "${layer.name || id}" is a type layer, which transforms as a whole; use content layer (or rasterize it to transform part of it).`);
+        const frame = typeFrame(layer, host.textEnv().shaper);
+        const m = textMatrix(layer);
+        const at = (x, y) => ({ x: m[0] * x + m[2] * y + m[4], y: m[1] * x + m[3] * y + m[5] });
+        this.typeTarget = layer;
+        this.typeLayer = true;
+        this.box = frame;
+        this.startGeometry = {
+          box: frame,
+          corners: [at(frame.x, frame.y), at(frame.x + frame.width, frame.y), at(frame.x + frame.width, frame.y + frame.height), at(frame.x, frame.y + frame.height)],
+          warp: null
+        };
+        this.geometryValue = this.startGeometry;
+        this.startInterp = this.interp;
+        this.moves = mask && linked ? ["pixels", "mask"] : ["pixels"];
+        if (mask && linked) this.parts.push({ what: "mask", offset: o, moving: mask.surface, base: null, reduced: /* @__PURE__ */ new Map() });
+        this.shown = this.startLayers;
+        return;
+      }
       if (layer.type === "shape" && !maskAlone) {
         if (content !== "layer") fail(`Layer "${layer.name || id}" is a shape layer, which transforms as a whole; use content layer (or rasterize it to transform part of it).`);
         const g = shapeGeometryBounds(layer);
@@ -2663,6 +2913,9 @@ var FreeTransformSession = class {
   /** True when the layer is a shape layer (the transform maps its paths and renders them again). */
   shapeLayer = false;
   shape = null;
+  /** True when the layer is a type layer (the transform sets its text matrix; affine only). */
+  typeLayer = false;
+  typeTarget = null;
   geometryValue;
   smart = null;
   smartReduced = /* @__PURE__ */ new Map();
@@ -2711,6 +2964,9 @@ var FreeTransformSession = class {
     };
     if (next.corners.length !== 4 || !next.corners.every((p) => Number.isFinite(p.x) && Number.isFinite(p.y))) fail("corners must be four finite points: top-left, top-right, bottom-right, bottom-left.");
     if (!transformMap(next)) fail("These corners fold the frame over itself or through the horizon; keep the quad convex.");
+    if (this.typeTarget && (hasWarp(next) || !matrixFromCorners(next.box, next.corners))) {
+      fail("Type layers take scale, rotate, skew and flips only (the corners must stay a parallelogram, no warp); rasterize the layer (rasterize_layer) for distort, perspective or warp.");
+    }
     this.geometryValue = next;
     if (preview !== false) this.render(preview);
     return next;
@@ -2718,6 +2974,7 @@ var FreeTransformSession = class {
   /** Resamples every part for the current geometry and shows it (or returns it, for commit). */
   resample(final, preview = {}) {
     if (this.smart) return { layers: this.resampleSmart(final, preview), selection: this.startSelection };
+    if (this.typeTarget) return { layers: this.resampleType(), selection: this.startSelection };
     const g = this.geometryValue;
     const identity = isIdentityTransform(g);
     const warp = hasWarp(g);
@@ -2798,6 +3055,27 @@ var FreeTransformSession = class {
     const surface = renderShape(moved, this.host.shapeEnv(), final ? {} : { clip: preview.clip });
     return mapLayer(this.startLayers, layer.id, () => ({ ...moved, surface }));
   }
+  /**
+   * A type layer with its text matrix set from the corners (affine only: scale, rotate, skew and
+   * flips), drawn again; a linked mask follows by the change's homography.
+   */
+  resampleType() {
+    const layer = this.typeTarget;
+    const g = this.geometryValue;
+    if (hasWarp(g)) fail("Type layers cannot be warped here; rasterize the layer first (rasterize_layer), or transform it with scale, rotate and skew.");
+    const m = matrixFromCorners(g.box, g.corners);
+    if (!m) fail("Type layers take scale, rotate, skew and flips only (the corners must stay a parallelogram); rasterize the layer for distort or perspective.");
+    const next = { ...layer, transform: m };
+    delete next.annotation;
+    let layers = mapLayer(this.startLayers, layer.id, () => rerenderText(next, this.host.textEnv()));
+    const change = multiplyHomographies(homographyFromAffine(invertMatrix(textMatrix(layer))), homographyFromAffine(m));
+    for (const part of this.parts) {
+      if (part.what !== "mask") continue;
+      const surface = transformSurface(part.moving, change, { interpolation: this.interp === "nearest" ? "nearest" : "bilinear" });
+      layers = mapLayer(layers, layer.id, (l) => ({ ...l, mask: { ...l.mask, surface } }));
+    }
+    return layers;
+  }
   /** A smart object re-rendered from its contents for the current geometry (previews leave the smart filters out). */
   resampleSmart(final, preview) {
     const layer = this.smart;
@@ -2821,7 +3099,7 @@ var FreeTransformSession = class {
   /** Whether the geometry (or the interpolation of a smart object) differs from where it started. */
   isChanged() {
     const g = this.geometryValue;
-    if (!this.smart) return !isIdentityTransform(g);
+    if (!this.smart && !this.typeTarget) return !isIdentityTransform(g);
     const a = this.startGeometry;
     const same = g.corners.every((c, i) => Math.abs(c.x - a.corners[i].x) < 1e-9 && Math.abs(c.y - a.corners[i].y) < 1e-9);
     const warp = (w, box) => w && hasWarp({ box, corners: a.corners, warp: w }) ? JSON.stringify(w) : "";
@@ -2858,7 +3136,7 @@ var FreeTransformSession = class {
     const id = this.copyId ?? this.layerId;
     const layer = id ? findLayer(layers, id)?.layer : void 0;
     if (this.moves.includes("pixels") && layer?.type === "pixel") bounds = toDoc(contentBounds(this.host.pixelsOf(layer)), layer.offset);
-    else if (this.moves.includes("pixels") && (layer?.type === "smart" || layer?.type === "shape")) bounds = contentBounds(layer.surface);
+    else if (this.moves.includes("pixels") && (layer?.type === "smart" || layer?.type === "shape" || layer?.type === "type")) bounds = contentBounds(layer.surface);
     else if (this.moves.includes("mask") && layer?.mask) bounds = toDoc(contentBounds(layer.mask.surface), layer.type === "pixel" ? layer.offset : { x: 0, y: 0 });
     else if (this.moves.includes("selection")) bounds = selection?.bounds ? { ...selection.bounds } : null;
     return {
@@ -3112,6 +3390,7 @@ var ImageEditorController = class {
   compositor = new LayerCompositor();
   constructor(options = {}) {
     this.maxHistoryDepth = options.maxHistoryDepth ?? 50;
+    if (options.textShaper !== void 0) this.textShaperValue = options.textShaper;
     this.maxHistoryBytes = options.maxHistoryBytes ?? 512 * 1024 * 1024;
     this.onStateChange = options.onStateChange;
     this.renderer = new ImageEditorRenderer();
@@ -3818,6 +4097,21 @@ var ImageEditorController = class {
       const b = shapeGeometryBounds(moved) ?? { x: 0, y: 0 };
       return { offset: { x: Math.round(b.x), y: Math.round(b.y) }, bounds: this.getLayerBounds(id) };
     }
+    if (layer.type === "type") {
+      const m = layer.transform ?? [1, 0, 0, 1, 0, 0];
+      const dx = move.x !== void 0 ? move.x - m[4] : move.dx ?? 0;
+      const dy = move.y !== void 0 ? move.y - m[5] : move.dy ?? 0;
+      if (!Number.isFinite(dx) || !Number.isFinite(dy)) throw new LayerOperationError("x and y must be numbers.");
+      requireUnlocked(layer, "position", "move it");
+      const mx = Math.round(dx);
+      const my = Math.round(dy);
+      let moved = { ...transformTypeLayer(layer, [1, 0, 0, 1, mx, my]), surface: translateSurface(layer.surface, mx, my) };
+      const mask = layer.mask;
+      if (mask && mask.linked !== false && !mask.source && (mx || my)) moved = { ...moved, mask: { ...mask, surface: translateSurface(mask.surface, mx, my) } };
+      this.commitLayers(mapLayer(this.state.layers, id, () => moved), void 0, commitToHistory);
+      const t = moved.transform ?? [1, 0, 0, 1, 0, 0];
+      return { offset: { x: Math.round(t[4]), y: Math.round(t[5]) }, bounds: this.getLayerBounds(id) };
+    }
     const current = layer.type === "pixel" ? layer.offset : { x: 0, y: 0 };
     const x = move.x ?? current.x + (move.dx ?? 0);
     const y = move.y ?? current.y + (move.dy ?? 0);
@@ -3966,6 +4260,7 @@ var ImageEditorController = class {
       canvas: () => this.naturalSize,
       pixelsOf: (layer) => this.surfaceOf(layer),
       shapeEnv: () => this.shapeEnv(),
+      textEnv: () => this.textEnv(),
       capture: () => this.captureHistoryEntry(),
       show: (layers, selection, active) => {
         this.state.layers = layers;
@@ -4066,7 +4361,7 @@ var ImageEditorController = class {
     if (turn !== 90 && turn !== -90 && turn !== 180) throw new LayerOperationError(`turn must be 90, -90 or 180, got ${String(turn)}.`);
     const session = this.beginFreeTransform({ interpolation: "nearest", ...init });
     try {
-      const b = session.smartObject ? transformedBox(session.startGeometry) ?? session.box : session.box;
+      const b = session.smartObject || session.typeLayer ? transformedBox(session.startGeometry) ?? session.box : session.box;
       const cx = b.x + b.width / 2;
       const cy = b.y + b.height / 2;
       const ox = turn === 180 ? 0 : Math.round(cx - b.height / 2) - (cx - b.height / 2);
@@ -4786,6 +5081,7 @@ var ImageEditorController = class {
     } else {
       if (layer.type === "smart") throw new LayerOperationError(`Layer "${layer.name || id}" is a smart object; its pixels come from its contents. Rasterize it (rasterize_smart_object), edit its contents (edit_smart_object_contents), or ${action} on its mask or filter mask.`);
       if (layer.type === "shape") throw new LayerOperationError(`Layer "${layer.name || id}" is a shape layer; its pixels are drawn from its paths. Rasterize it first (rasterize_layer), or ${action} on its mask (channel mask).`);
+      if (layer.type === "type") throw new LayerOperationError(`Layer "${layer.name || id}" is a type layer; its pixels are drawn from its text. Rasterize it first (rasterize_layer), or ${action} on its mask (channel mask).`);
       if (layer.type !== "pixel") throw new LayerOperationError(`Layer "${layer.name || id}" is a ${layer.type} layer; ${action} on a pixel layer, or on this layer's mask (channel mask).`);
       requireUnlocked(layer, "pixels", action);
     }
@@ -5491,7 +5787,11 @@ var ImageEditorController = class {
   // --- Annotations & Layers ---
   /** The layer showing annotation `id`: an annotation layer, or a shape layer migrated from it. */
   annotationLayer(id) {
-    return flattenLayers(this.state.layers).find((l) => (l.type === "annotation" || l.type === "shape") && annotationOfLayer(l)?.id === id);
+    return flattenLayers(this.state.layers).find((l) => (l.type === "annotation" || l.type === "shape" || l.type === "type") && annotationOfLayer(l)?.id === id);
+  }
+  /** What migrating an annotation needs: the canvas size, patterns and the text shaper. */
+  annotationEnv() {
+    return { ...this.shapeEnv(), ...this.textEnv() };
   }
   /**
    * Adds an annotation as its own layer (top of the stack unless `aboveId` is given). Pen,
@@ -5503,7 +5803,7 @@ var ImageEditorController = class {
     this.recordHistory();
     const id = `ann_${Date.now()}_${Math.random().toString(36).slice(2, 7)}`;
     const fullAnnotation = { ...annotation, id };
-    const layer = annotationLayerFor(fullAnnotation, this.shapeEnv());
+    const layer = annotationLayerFor(fullAnnotation, this.annotationEnv());
     const loc = placement.aboveId ? findLayer(this.state.layers, placement.aboveId) : null;
     this.state.layers = loc ? insertLayer(this.state.layers, layer, loc.parent?.id ?? null, loc.index + 1) : insertLayer(this.state.layers, layer, null);
     this.state.selectedAnnotationId = id;
@@ -5523,24 +5823,14 @@ var ImageEditorController = class {
     }
     this.notify();
   }
-  /** `layer` (an annotation or migrated shape layer) showing `annotation` instead, keeping its other properties. */
+  /** `layer` (an annotation, or a shape or type layer migrated from one) showing `annotation` instead, keeping its other properties. */
   layerForAnnotation(layer, annotation, name) {
-    const shape = shapeFromAnnotation(annotation);
-    const { annotation: _old, ...props } = layer;
-    const blend = annotation.blend && annotation.blend !== "normal" ? annotation.blend : "normal";
-    if (shape) {
-      const base = { ...props, name, blend: layer.type === "annotation" && layer.blend !== "normal" ? layer.blend : blend };
-      if (layer.type === "shape") {
-        const fresh = rerenderShape({ ...base, components: shape.components, fill: shape.fill, stroke: shape.stroke }, this.shapeEnv());
-        delete fresh.fillRule;
-        return { ...fresh, annotation };
-      }
-      const created = createShapeLayer({ ...shape, name, blend: base.blend }, this.shapeEnv(), layer.id);
-      const { type: _t2, ...rest2 } = base;
-      return { ...rest2, ...created, annotation };
-    }
-    const { type: _t, components: _c, fill: _f, stroke: _s, surface: _sf, offset: _o, fillRule: _r, fillOpacity: _fo, psd: _p, ...rest } = props;
-    return { ...rest, type: "annotation", name, blend: layer.type === "shape" ? "normal" : layer.blend, annotation };
+    const fresh = annotationLayerFor(annotation, this.annotationEnv());
+    const keep = { id: layer.id, visible: layer.visible, opacity: layer.opacity };
+    for (const k of ["clipped", "mask", "locks", "effects"]) if (layer[k] !== void 0) keep[k] = layer[k];
+    if (fresh.type !== "annotation" && layer.type !== "annotation" && layer.fillOpacity !== void 0) keep.fillOpacity = layer.fillOpacity;
+    const blend = fresh.type === "annotation" ? layer.type === "annotation" ? layer.blend : "normal" : layer.type === "annotation" && layer.blend !== "normal" ? layer.blend : fresh.blend;
+    return { ...fresh, ...keep, name, blend };
   }
   removeAnnotation(id) {
     this.recordHistory();
@@ -5555,7 +5845,7 @@ var ImageEditorController = class {
   clearAnnotations() {
     this.recordHistory();
     let layers = this.state.layers;
-    for (const l of flattenLayers(layers)) if (l.type === "annotation" || l.type === "shape" && l.annotation) layers = mapLayer(layers, l.id, () => null);
+    for (const l of flattenLayers(layers)) if (l.type === "annotation" || (l.type === "shape" || l.type === "type") && l.annotation) layers = mapLayer(layers, l.id, () => null);
     this.state.layers = layers;
     this.state.selectedAnnotationId = null;
     this.notify();
@@ -5794,6 +6084,233 @@ var ImageEditorController = class {
     this.commitLayers(setLayerMask(this.state.layers, target.id, { surface, defaultValue: 0 }));
     return target.id;
   }
+  // --- Type layers ---
+  textShaperValue;
+  /** The shaper that lays out and draws type layers (`null` when there is none here). */
+  getTextShaper() {
+    if (this.textShaperValue === void 0) this.textShaperValue = createCanvasTextShaper({ createCanvas: (w, h) => this.renderer.createCanvas(w, h) });
+    return this.textShaperValue;
+  }
+  /** Sets the text shaper (fonts) type layers lay out and draw with; existing layers redraw on their next edit. */
+  setTextShaper(shaper) {
+    this.textShaperValue = shaper;
+    this.notify();
+  }
+  /** What type layers lay out and draw with. */
+  textEnv() {
+    return { ...this.naturalSize, shaper: this.getTextShaper(), createCanvas: (w, h) => this.renderer.createCanvas(w, h) };
+  }
+  /** Font families the shaper offers (generic families at least). */
+  listFonts() {
+    return this.getTextShaper()?.families?.() ?? ["sans-serif", "serif", "monospace"];
+  }
+  typeInfo(id) {
+    const layer = requireTypeLayer(this.state.layers, id);
+    const ranges = (runs) => {
+      let at = 0;
+      return runs.map((r) => {
+        const out = { start: at, end: at + r.length, style: JSON.parse(JSON.stringify(r.style)) };
+        at += r.length;
+        return out;
+      });
+    };
+    const shaper = this.getTextShaper();
+    let lines = [];
+    let missing = layer.missingFonts ?? [];
+    if (shaper) {
+      const layout = layoutText(layer, shaper);
+      const r = (n) => Math.round(n * 1e3) / 1e3;
+      lines = layout.lines.map((l) => ({ start: l.start, end: l.end, baseline: r(l.baseline), width: r(l.width) }));
+      if (layer.rendering === "stored") missing = layout.missingFonts;
+    }
+    const info = {
+      id: layer.id,
+      name: layer.name,
+      text: layer.text,
+      runs: ranges(layer.runs),
+      paragraphs: ranges(layer.paragraphs),
+      frame: { ...layer.frame },
+      transform: [...layer.transform ?? [1, 0, 0, 1, 0, 0]],
+      lines,
+      bounds: this.getLayerBounds(id),
+      missingFonts: [...missing],
+      rendering: layer.rendering === "stored" ? "stored" : "live"
+    };
+    if (layer.annotation) info.annotationId = layer.annotation.id;
+    return info;
+  }
+  /** A type layer's text, runs, paragraphs, frame, lines and bounds. */
+  getTextLayer(id) {
+    return this.typeInfo(id);
+  }
+  /**
+   * Adds a type layer (one undo step) and makes it active: point text at `x`, `y`, or paragraph
+   * text wrapped in `box`. Refused without a text shaper. Returns its id.
+   */
+  addTextLayer(init) {
+    const text = normalizeText(init.text);
+    if (!Number.isFinite(init.x) || !Number.isFinite(init.y)) throw new LayerOperationError("x and y must be numbers (document pixels).");
+    const style = patchTextStyle({ ...DEFAULT_TEXT_STYLE, color: this.state.paint.foreground }, init.style ?? {});
+    const paragraph = patchParagraphStyle({}, init.paragraph ?? {});
+    let frame = { kind: "point" };
+    if (init.box) {
+      const { width, height } = init.box;
+      if (!(Number.isFinite(width) && width >= 1 && Number.isFinite(height) && height >= 1)) throw new LayerOperationError("box.width and box.height must be at least 1 pixel.");
+      frame = { kind: "box", width, height };
+    }
+    if (init.rotation !== void 0 && !Number.isFinite(init.rotation)) throw new LayerOperationError("rotation must be a number of degrees.");
+    if (init.opacity !== void 0 && !(Number.isFinite(init.opacity) && init.opacity >= 0 && init.opacity <= 1)) throw new LayerOperationError("opacity must be between 0 and 1.");
+    if (init.blend !== void 0 && !isBlendMode(init.blend)) throw new LayerOperationError(`Unknown blend mode "${String(init.blend)}".`);
+    const t = [1, 0, 0, 1, init.x, init.y];
+    const transform = init.rotation ? multiplyMatrices(t, rotateMatrix(init.rotation, { x: init.x, y: init.y })) : t;
+    const layer = createTypeLayer({ text, runs: [{ length: text.length, style }], paragraphs: [{ length: text.length, style: paragraph }], frame, transform, name: init.name ?? typeLayerName(text) }, this.textEnv());
+    if (init.opacity !== void 0) layer.opacity = init.opacity;
+    if (init.blend !== void 0) layer.blend = init.blend;
+    const next = placeLayer(this.state.layers, layer, this.newLayerPlacement(init));
+    this.commitLayers(next, () => {
+      this.state.activeLayerId = layer.id;
+      this.state.activeTarget = "pixels";
+    });
+    return layer.id;
+  }
+  /**
+   * Replaces text [start, end) (default all of it) with `text`; inserted text takes the style at
+   * `start`. One undo step unless `commitToHistory` is false (typing). Returns the layer.
+   */
+  setText(id, text, range = {}, commitToHistory = true) {
+    const layer = requireTypeLayer(this.state.layers, id);
+    const insert = normalizeText(text);
+    const [start, end] = textRange(layer.text, range.start, range.end);
+    const { layers } = updateTypeLayer(this.state.layers, id, (l) => replaceTextRange(l, start, end, insert), this.textEnv(), "edit its text");
+    this.commitLayers(layers, void 0, commitToHistory);
+    return this.typeInfo(id);
+  }
+  /** Sets character style fields over [start, end) (default all), one undo step. Returns the layer. */
+  setTextStyle(id, style, range = {}, commitToHistory = true) {
+    const layer = requireTypeLayer(this.state.layers, id);
+    const [start, end] = textRange(layer.text, range.start, range.end);
+    if (!Object.keys(style).length) throw new LayerOperationError("Give at least one style field to set.");
+    patchTextStyle(DEFAULT_TEXT_STYLE, style);
+    const { layers } = updateTypeLayer(
+      this.state.layers,
+      id,
+      (l) => {
+        if (start === end) {
+          if (l.text.length) throw new LayerOperationError("The range is empty; give start < end (or leave both out for the whole text).");
+          return { runs: [{ length: 0, style: patchTextStyle(styleAt(l.runs, 0, DEFAULT_TEXT_STYLE), style) }] };
+        }
+        return { runs: restyleRange(l.runs, start, end, (s) => patchTextStyle(s, style)) };
+      },
+      this.textEnv(),
+      "restyle its text"
+    );
+    this.commitLayers(layers, void 0, commitToHistory);
+    return this.typeInfo(id);
+  }
+  /** Sets paragraph style fields on every paragraph that [start, end) touches (default all), one undo step. */
+  setParagraphStyle(id, style, range = {}, commitToHistory = true) {
+    const layer = requireTypeLayer(this.state.layers, id);
+    const [start, end] = textRange(layer.text, range.start, range.end);
+    if (!Object.keys(style).length) throw new LayerOperationError("Give at least one paragraph field to set.");
+    patchParagraphStyle({}, style);
+    const { layers } = updateTypeLayer(
+      this.state.layers,
+      id,
+      (l) => {
+        let at = 0;
+        const paragraphs = l.paragraphs.map((p) => {
+          const a = at;
+          at += p.length;
+          const touches = a < end && at > start || start === end && start >= a && (start < at || at === l.text.length);
+          return touches || !l.text.length ? { length: p.length, style: patchParagraphStyle(p.style, style) } : p;
+        });
+        return { paragraphs };
+      },
+      this.textEnv(),
+      "restyle its paragraphs"
+    );
+    this.commitLayers(layers, void 0, commitToHistory);
+    return this.typeInfo(id);
+  }
+  /**
+   * Point text ↔ paragraph text: `{ kind: 'box', width, height }` wraps the text in a box (its
+   * top-left where the first line's top-left is now), `{ kind: 'point' }` sets it on one line per
+   * paragraph. Also resizes a box. One undo step.
+   */
+  setTextFrame(id, frame, commitToHistory = true) {
+    const layer = requireTypeLayer(this.state.layers, id);
+    if (frame.kind === "box" && !(Number.isFinite(frame.width) && frame.width >= 1 && Number.isFinite(frame.height) && frame.height >= 1)) throw new LayerOperationError("width and height must be at least 1 pixel.");
+    if (frame.kind !== "box" && frame.kind !== "point") throw new LayerOperationError("kind must be point or box.");
+    const shaper = this.getTextShaper();
+    const { layers } = updateTypeLayer(
+      this.state.layers,
+      id,
+      (l) => {
+        if (frame.kind === "box" && l.frame.kind === "box") return { frame: { kind: "box", width: frame.width, height: frame.height } };
+        if (!shaper) throw new LayerOperationError("Changing between point and paragraph text needs a text shaper to measure the text.");
+        const lines = layoutText(l, shaper).lines;
+        const first = lines[0];
+        const dx = frame.kind === "box" ? first ? first.x : 0 : 0;
+        const dy = frame.kind === "box" ? first ? first.baseline - first.ascent : 0 : first ? first.baseline : 0;
+        const m = textMatrix(l);
+        const shifted = [m[0], m[1], m[2], m[3], m[0] * dx + m[2] * dy + m[4], m[1] * dx + m[3] * dy + m[5]];
+        const nextFrame = frame.kind === "box" ? { kind: "box", width: frame.width, height: frame.height } : { kind: "point" };
+        return { frame: nextFrame, transform: shifted };
+      },
+      this.textEnv(),
+      "change its frame"
+    );
+    this.commitLayers(layers, void 0, commitToHistory);
+    return this.typeInfo(id);
+  }
+  /**
+   * Convert to Shape: the text's glyph outlines become a shape layer with the same id, name and
+   * layer properties (needs a shaper that gives outlines). The fill is the first run's colour;
+   * `warnings` says when other colours were dropped. One undo step.
+   */
+  convertTextToShape(id) {
+    const layer = requireTypeLayer(this.state.layers, id);
+    requireUnlocked(layer, "all", "convert it");
+    const shaper = this.getTextShaper();
+    if (!shaper) throw new LayerOperationError("Convert to Shape needs a text shaper that gives glyph outlines; none is set here.");
+    const parts = textOutlines(layer, shaper);
+    const subpaths = parts.flatMap((p) => bezierToSubpaths(p.path));
+    if (!subpaths.length) throw new LayerOperationError("The text draws nothing (it is empty or only spaces), so there is no shape to make.");
+    const warnings = [];
+    const colors = new Set(layer.runs.filter((r) => r.length > 0).map((r) => `${r.style.color}/${r.style.opacity ?? 1}`));
+    if (colors.size > 1) warnings.push("The text had several colours; the shape takes the first one.");
+    const missing = layoutText(layer, shaper).missingFonts;
+    if (missing.length) warnings.push(`Missing fonts were drawn with a fallback: ${missing.join(", ")}.`);
+    const first = layer.runs.find((r) => r.length > 0)?.style ?? DEFAULT_TEXT_STYLE;
+    const fill = first.opacity !== void 0 && first.opacity !== 1 ? { type: "color", color: first.color, opacity: first.opacity } : { type: "color", color: first.color };
+    const shape = createShapeLayer({ components: [{ op: "combine", subpaths }], fill, stroke: null, name: layer.name }, this.shapeEnv(), layer.id);
+    const keep = { visible: layer.visible, opacity: layer.opacity, blend: layer.blend };
+    for (const k of ["clipped", "mask", "locks", "effects", "fillOpacity"]) if (layer[k] !== void 0) keep[k] = layer[k];
+    this.commitLayers(mapLayer(this.state.layers, id, () => ({ ...shape, ...keep })));
+    return { layerId: id, warnings };
+  }
+  /** The layout of a type layer (lines, characters, bounds in text space), or `null` without a shaper. */
+  getTextLayout(id) {
+    const layer = requireTypeLayer(this.state.layers, id);
+    const shaper = this.getTextShaper();
+    return shaper ? layoutText(layer, shaper) : null;
+  }
+  /** The text index nearest a document point (for clicks on a type layer). */
+  textIndexAt(id, point) {
+    const layer = requireTypeLayer(this.state.layers, id);
+    const layout = this.getTextLayout(id);
+    return layout ? textIndexAt(layout, toTextSpace(layer, point)) : layer.text.length;
+  }
+  /** The caret at text index `index` as a document-space segment (top to bottom), for drawing it. */
+  textCaret(id, index) {
+    const layer = requireTypeLayer(this.state.layers, id);
+    const layout = this.getTextLayout(id);
+    if (!layout) return null;
+    const c = caretAt(layout, Math.max(0, Math.min(layer.text.length, index)));
+    const m = textMatrix(layer);
+    const at = (x, y) => ({ x: m[0] * x + m[2] * y + m[4], y: m[1] * x + m[3] * y + m[5] });
+    return { top: at(c.x, c.top), bottom: at(c.x, c.bottom), line: c.line };
+  }
   // --- Shape layers ---
   /** What shape rendering needs: the canvas size and the document's patterns. */
   shapeEnv() {
@@ -5970,11 +6487,11 @@ var ImageEditorController = class {
       }
     } else if (layer.type === "smart") {
       return this.rasterizeSmartObject(id);
-    } else if (layer.type === "shape") {
-      next = shapeAsPixelLayer(layer);
+    } else if (layer.type === "shape" || layer.type === "type") {
+      next = layer.type === "shape" ? shapeAsPixelLayer(layer) : typeAsPixelLayer(layer);
       if (this.state.selectedAnnotationId && this.state.selectedAnnotationId === layer.annotation?.id) this.state.selectedAnnotationId = null;
     } else {
-      throw new LayerOperationError(`Only shape and annotation layers, smart objects and pixel layers with filters rasterize; "${layer.name || id}" is a ${layer.type} layer. Merge it down or flatten instead.`);
+      throw new LayerOperationError(`Only shape, type and annotation layers, smart objects and pixel layers with filters rasterize; "${layer.name || id}" is a ${layer.type} layer. Merge it down or flatten instead.`);
     }
     this.commitLayers(mapLayer(this.state.layers, id, () => next));
     return id;
@@ -5997,7 +6514,7 @@ var ImageEditorController = class {
     s.sourceUrl = null;
     s.imageDimensions = { width: result.width, height: result.height };
     if (!this.samplePixelsOverride) this.samplePixels = null;
-    s.layers = result.layers;
+    s.layers = this.checkPsdFonts(result);
     s.crop = null;
     s.transform = { ...DEFAULT_TRANSFORM_VALUES };
     s.outputOpacity = 1;
@@ -6022,6 +6539,30 @@ var ImageEditorController = class {
       summary: result.summary
     };
   }
+  /**
+   * Type layers whose fonts the shaper lacks: they keep Photoshop's pixels, are marked with their
+   * `missingFonts`, and a warning names them (an edit draws them with a fallback).
+   */
+  checkPsdFonts(result) {
+    const shaper = this.getTextShaper();
+    const types = flattenLayers(result.layers).filter((l) => l.type === "type");
+    if (!types.length) return result.layers;
+    let layers = result.layers;
+    const missing = /* @__PURE__ */ new Map();
+    for (const l of types) {
+      const fonts = shaper ? layoutText(l, shaper).missingFonts : [...new Set(l.runs.map((r) => r.style.fontFamily))];
+      if (!fonts.length) continue;
+      layers = mapLayer(layers, l.id, () => ({ ...l, missingFonts: fonts }));
+      for (const f of fonts) missing.set(f, [...missing.get(f) ?? [], l.name]);
+    }
+    for (const [font, names] of missing) {
+      result.warnings.push(
+        shaper ? `The font "${font}" is missing here: the type shows Photoshop's pixels until it is edited, then a fallback font (${names.length === 1 ? "layer" : "layers"} ${names.map((n) => `"${n}"`).join(", ")}).` : `Type layers show Photoshop's pixels; nothing here can draw text, so they cannot be edited (${names.length === 1 ? "layer" : "layers"} ${names.map((n) => `"${n}"`).join(", ")}).`
+      );
+      if (!shaper) break;
+    }
+    return layers;
+  }
   /**
    * The document as an 8-bit RGB PSD (PSB above 30 000 px) with real layers, groups, adjustment
    * layers and masks, in the source frame. Layer filters and parametric (depth) masks are baked
@@ -6099,9 +6640,9 @@ var ImageEditorController = class {
         if (mask2) out2.mask = mask2;
         return out2;
       }
-      if (layer.type === "shape") {
-        add2("Shape layers were written as pixel layers", layer.name);
-        const out2 = shapeAsPixelLayer(layer);
+      if (layer.type === "shape" || layer.type === "type") {
+        if (layer.type === "type" && layer.missingFonts?.length) add2(`Type layers drawn with a fallback for missing fonts (${layer.missingFonts.join(", ")}) keep the font names, so Photoshop may draw them differently`, layer.name);
+        const out2 = { ...layer };
         const mask2 = bakeMask(layer);
         if (mask2) out2.mask = mask2;
         else delete out2.mask;
@@ -6203,7 +6744,7 @@ var ImageEditorController = class {
     const bg = developTarget(layers, null);
     if (bg && bg.source !== "document") layers = mapLayer(layers, bg.id, () => ({ ...bg, source: "document" }));
     if (clearAnnotations) {
-      for (const l of flattenLayers(layers)) if (l.type === "annotation" || l.type === "shape" && l.annotation) layers = mapLayer(layers, l.id, () => null);
+      for (const l of flattenLayers(layers)) if (l.type === "annotation" || (l.type === "shape" || l.type === "type") && l.annotation) layers = mapLayer(layers, l.id, () => null);
       this.state.selectedAnnotationId = null;
     }
     this.state.layers = layers;
@@ -6279,7 +6820,8 @@ var ImageEditorController = class {
         problems,
         smartContents: Array.isArray(data.smartContents) ? data.smartContents : [],
         canvas,
-        pattern: (pid) => storedPatterns.find((p) => p.id === pid) ?? null
+        pattern: (pid) => storedPatterns.find((p) => p.id === pid) ?? null,
+        text: this.textEnv()
       });
       this.lastLoadProblems = problems;
       s.crop = data.crop ? { ...data.crop } : null;
@@ -6482,7 +7024,7 @@ function collectStateTiles(layers, into) {
   for (const l of flattenLayers(layers)) {
     if (l.type === "pixel" && l.source !== "document") collectTiles(l.surface, into);
     if (l.mask && !l.mask.source) collectTiles(l.mask.surface, into);
-    if (l.type === "shape") collectTiles(l.surface, into);
+    if (l.type === "shape" || l.type === "type") collectTiles(l.surface, into);
     if (l.type === "smart") {
       collectTiles(l.surface, into);
       if (l.smartFilters?.mask) collectTiles(l.smartFilters.mask.surface, into);
@@ -6531,7 +7073,7 @@ function resizePixels(px2, width, height) {
 function withoutAnnotations(layers) {
   const out = [];
   for (const l of layers) {
-    if (l.type === "annotation" || l.type === "shape" && l.annotation) continue;
+    if (l.type === "annotation" || (l.type === "shape" || l.type === "type") && l.annotation) continue;
     out.push(l.type === "group" ? { ...l, children: withoutAnnotations(l.children) } : l);
   }
   return out;
@@ -6721,7 +7263,7 @@ function loadImageEditorDocument(input) {
   if (state.selection === void 0) delete state.selection;
   return { state, report: result.report, unknown: result.unknown };
 }
-var LAYER_TYPES = /* @__PURE__ */ new Set(["pixel", "adjustment", "group", "annotation", "smart", "shape"]);
+var LAYER_TYPES = /* @__PURE__ */ new Set(["pixel", "adjustment", "group", "annotation", "smart", "shape", "type"]);
 function cleanLayers(value, dropped) {
   const out = [];
   for (const raw of value) {
@@ -7781,6 +8323,18 @@ function describeLayer(layer, activeId, boundsOf) {
       };
       if (layer.annotation) out.annotation = { id: layer.annotation.id, type: layer.annotation.type };
       break;
+    case "type":
+      out.bounds = boundsOf(layer);
+      out.fillOpacity = round3(layer.fillOpacity ?? 1);
+      out.text = {
+        text: layer.text.length > 80 ? `${layer.text.slice(0, 80)}\u2026` : layer.text,
+        frame: layer.frame.kind,
+        runs: layer.runs.length,
+        rendering: layer.rendering === "stored" ? "stored" : "live",
+        missingFonts: layer.missingFonts ?? []
+      };
+      if (layer.annotation) out.annotation = { id: layer.annotation.id, type: layer.annotation.type };
+      break;
     case "smart":
       out.bounds = boundsOf(layer);
       out.fillOpacity = round3(layer.fillOpacity ?? 1);
@@ -7826,7 +8380,7 @@ function createImageLayerTools(controller) {
   const listLayers = {
     name: "list_layers",
     title: "List image layers",
-    description: "Returns the layer stack bottom to top as a tree: id, type (pixel, adjustment, group, shape, smart, annotation), name, document bounds (pixel, shape and smart layers), visible, opacity, fillOpacity, blend, clipped, locks, a mask summary, an effects summary (master switch, scale, effect ids and kinds; details from list_layer_effects), filters (pixel layers), kind and params (adjustment layers), a shape summary (component operations and kinds, fill and stroke paint types; details from get_shape_layer), children (groups) and which layer is active. Also returns the active layer id and target (pixels or mask) and the canvas size.",
+    description: "Returns the layer stack bottom to top as a tree: id, type (pixel, adjustment, group, shape, type, smart, annotation), name, document bounds (pixel, shape, type and smart layers), visible, opacity, fillOpacity, blend, clipped, locks, a mask summary, an effects summary (master switch, scale, effect ids and kinds; details from list_layer_effects), filters (pixel layers), kind and params (adjustment layers), a shape summary (component operations and kinds, fill and stroke paint types; details from get_shape_layer), a text summary (the text, point or box frame, run count, live or stored pixels, missing fonts; details from get_text_layer), children (groups) and which layer is active. Also returns the active layer id and target (pixels or mask) and the canvas size.",
     inputSchema: { type: "object", properties: {}, additionalProperties: false },
     annotations: { title: "List image layers", ...READ2 },
     handler: () => {
@@ -8170,7 +8724,7 @@ function createImageLayerTools(controller) {
   const rasterize = {
     name: "rasterize_layer",
     title: "Rasterize a layer",
-    description: "Rasterize Layer: turns a shape layer into a pixel layer holding what it shows now (same id, name, opacity, blend, fill, mask and effects; its paths are gone, so later transforms resample pixels), turns an annotation layer into a pixel layer (needs a browser), rasterizes a smart object, or bakes a pixel layer's filters (develop, blur) into its pixels. One undo step. Returns the layer.",
+    description: "Rasterize Layer: turns a shape or type layer into a pixel layer holding what it shows now (same id, name, opacity, blend, fill, mask and effects; its paths are gone, so later transforms resample pixels), turns an annotation layer into a pixel layer (needs a browser), rasterizes a smart object, or bakes a pixel layer's filters (develop, blur) into its pixels. One undo step. Returns the layer.",
     inputSchema: { type: "object", properties: { layerId: LAYER_ID2 }, required: ["layerId"], additionalProperties: false },
     annotations: { title: "Rasterize a layer", ...DESTRUCTIVE },
     handler: async ({ layerId }) => ({ layer: describe(await controller.rasterizeLayer(exists(layerId))) })
@@ -8501,7 +9055,7 @@ function createImageEffectTools(controller) {
   const add2 = {
     name: "add_layer_effect",
     title: "Add a layer effect",
-    description: "Adds a live effect to a pixel, annotation or group layer with Photoshop's defaults, changed by settings: drop-shadow, inner-shadow, outer-glow, inner-glow, bevel-emboss, satin, color-overlay, gradient-overlay, pattern-overlay or stroke. Several of one kind are allowed (the first listed is on top). One undo step. Returns the new effect's id and the layer's effects.",
+    description: "Adds a live effect to a pixel, shape, type, smart object, annotation or group layer with Photoshop's defaults, changed by settings: drop-shadow, inner-shadow, outer-glow, inner-glow, bevel-emboss, satin, color-overlay, gradient-overlay, pattern-overlay or stroke. Several of one kind are allowed (the first listed is on top). One undo step. Returns the new effect's id and the layer's effects.",
     inputSchema: {
       type: "object",
       $defs: DEFS,
@@ -8975,7 +9529,7 @@ function createImagePsdTools(controller) {
   const open = {
     name: "import_psd",
     title: "Open a PSD as the document",
-    description: "Opens a PSD / PSB as the document, replacing the current layers, crop and rotation (one undo step; undo brings the previous document back). Pixel, group and adjustment layers, masks, blend modes, opacity, fill, clipping, visibility, locks, layer effects (with the patterns and global light of the file) map directly; smart objects come in as smart objects (embedded contents, placement and warp, smart filters: Box Blur is drawn, other Photoshop filters are kept but not drawn, filter mask; linked contents as their stored pixels); type, fill and shape layers come in as their pixels; unsupported adjustments are left out. Returns the new layer tree with ids, the size and the warnings (each names the affected layers).",
+    description: "Opens a PSD / PSB as the document, replacing the current layers, crop and rotation (one undo step; undo brings the previous document back). Pixel, group and adjustment layers, masks, blend modes, opacity, fill, clipping, visibility, locks, layer effects (with the patterns and global light of the file) map directly; smart objects come in as smart objects (embedded contents, placement and warp, smart filters: Box Blur is drawn, other Photoshop filters are kept but not drawn, filter mask; linked contents as their stored pixels); shape layers come in as live shapes (paths, path operations, fill, stroke, live rectangles, ellipses and lines); type layers come in as live text (runs, paragraphs, frame, transform) showing Photoshop\u2019s pixels until edited, with a warning for fonts missing here; fill layers come in as their pixels; unsupported adjustments are left out. Returns the new layer tree with ids, the size and the warnings (each names the affected layers).",
     inputSchema: { type: "object", properties: { data: DATA }, required: ["data"], additionalProperties: false },
     annotations: { title: "Open a PSD as the document", ...DESTRUCTIVE4 },
     handler: ({ data }) => {
@@ -8994,7 +9548,7 @@ function createImagePsdTools(controller) {
   const save = {
     name: "export_psd",
     title: "Export the document as a PSD",
-    description: "Writes the document as an 8-bit RGB PSD (a PSB above 30000 px) with real layers, groups, adjustment layers, masks and layer effects (an effects block opened from a PSD is written back unchanged while its effects are; the patterns effects use are embedded), in the source frame (crop and rotation are not applied). Smart objects are written as Photoshop smart objects (contents embedded once per linked set, placement, warp, smart filters and filter mask; a Develop smart filter has no Photoshop filter and is left out of the list). Layer filters and depth masks are baked, annotation layers are rasterized (in a browser; elsewhere left out), and the merged image is the editor's composite. Changes nothing. Returns the file as base64, its size in bytes, whether it is a PSB, and warnings for everything that was changed or left out.",
+    description: "Writes the document as an 8-bit RGB PSD (a PSB above 30000 px) with real layers, groups, adjustment layers, masks and layer effects (an effects block opened from a PSD is written back unchanged while its effects are; the patterns effects use are embedded), in the source frame (crop and rotation are not applied). Smart objects are written as Photoshop smart objects (contents embedded once per linked set, placement, warp, smart filters and filter mask; a Develop smart filter has no Photoshop filter and is left out of the list). Shape layers are written as Photoshop shape layers (path, fill, stroke, live shapes) and type layers as Photoshop type layers (text, runs, paragraphs, frame; blocks opened from a PSD are written back unchanged while the layer is). Layer filters and depth masks are baked, annotation layers are rasterized (in a browser; elsewhere left out), and the merged image is the editor's composite. Changes nothing. Returns the file as base64, its size in bytes, whether it is a PSB, and warnings for everything that was changed or left out.",
     inputSchema: { type: "object", properties: {}, additionalProperties: false },
     annotations: { title: "Export the document as a PSD", ...READ5 },
     handler: async () => {
@@ -10019,6 +10573,176 @@ function createImageShapeTools(controller) {
   return [get, add2, update, setComponent, addComponent, removeComponent, merge];
 }
 
+// src/image-editor/type-tools.ts
+var READ9 = { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false };
+var WRITE8 = { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false };
+var WRITE_IDEMPOTENT6 = { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false };
+var DESTRUCTIVE7 = { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: false };
+var LAYER_ID6 = { type: "string", description: "Type layer id from list_layers (type type) or add_text_layer." };
+var START = { type: "integer", minimum: 0, description: "Start of the range in UTF-16 code units, as get_text_layer counts them (default 0)." };
+var END = { type: "integer", minimum: 0, description: "End of the range, exclusive (default the end of the text)." };
+var STYLE = {
+  fontFamily: { type: "string", description: "Font family name (list_fonts shows what is available; a missing family falls back, with a warning)." },
+  fontWeight: { type: "integer", minimum: 1, maximum: 1e3, description: "Weight 100..900 (400 regular, 700 bold)." },
+  italic: { type: "boolean", description: "Italic." },
+  fontSize: { type: "number", minimum: 0.5, maximum: 5e3, description: "Size in document pixels." },
+  color: { type: "string", description: "Colour (#rrggbb, or a CSS colour; its alpha becomes opacity)." },
+  opacity: { type: ["number", "null"], minimum: 0, maximum: 1, description: "Text opacity 0..1 (null resets to 1)." },
+  tracking: { type: ["number", "null"], minimum: -1e3, maximum: 1e4, description: "Letter spacing in 1/1000 em (null resets to 0)." },
+  leading: { type: ["number", "null"], minimum: 0, maximum: 1e4, description: "Baseline-to-baseline distance in pixels (null = auto, the paragraph autoLeading \xD7 size)." },
+  baselineShift: { type: ["number", "null"], minimum: -5e3, maximum: 5e3, description: "Pixels; positive raises the text (null resets to 0)." },
+  underline: { type: "boolean", description: "Underline." },
+  strikethrough: { type: "boolean", description: "Strike through." }
+};
+var PARAGRAPH = {
+  align: { type: "string", enum: ["left", "center", "right", "justify"], description: "Alignment (justify stretches paragraph-box lines but the last)." },
+  autoLeading: { type: ["number", "null"], minimum: 0.1, maximum: 10, description: "Auto leading as a multiple of the font size (default 1.2)." },
+  firstLineIndent: { type: ["number", "null"], description: "First-line indent in pixels." },
+  startIndent: { type: ["number", "null"], description: "Left indent in pixels." },
+  endIndent: { type: ["number", "null"], description: "Right indent in pixels." },
+  spaceBefore: { type: ["number", "null"], description: "Space above the paragraph in pixels (not before the first)." },
+  spaceAfter: { type: ["number", "null"], description: "Space below the paragraph in pixels." }
+};
+function pick(args, keys) {
+  const out = {};
+  for (const k of keys) if (args[k] !== void 0) out[k] = args[k];
+  return out;
+}
+function createImageTypeTools(controller) {
+  const typeId = (id) => {
+    if (typeof id !== "string" || !id) throw new LayerOperationError("layerId is required (a type layer id from list_layers).");
+    requireTypeLayer(controller.getLayers(), id);
+    return id;
+  };
+  const layerSummary = (id) => {
+    const s = controller.getState();
+    const loc = findLayer(s.layers, id);
+    return loc ? { ...describeLayer(loc.layer, s.activeLayerId, (x) => controller.getLayerBounds(x.id)), parentId: loc.parent?.id ?? null, index: loc.index } : null;
+  };
+  const range = (args) => ({ start: args.start, end: args.end });
+  const listFonts = {
+    name: "list_fonts",
+    title: "List fonts",
+    description: "Returns the font families type layers can use here (generic families such as sans-serif always work). Changes nothing.",
+    inputSchema: { type: "object", properties: {}, additionalProperties: false },
+    annotations: { title: "List fonts", ...READ9 },
+    handler: () => ({ families: controller.listFonts(), shaper: controller.getTextShaper()?.id ?? null })
+  };
+  const get = {
+    name: "get_text_layer",
+    title: "Read a type layer",
+    description: "Returns a type layer\u2019s text, its character runs and paragraphs as [start, end) ranges in UTF-16 code units with their styles, the frame (point text, or a paragraph box with its size), the text-to-document transform, the laid-out lines (range, baseline, width), the rendered bounds, missing fonts and whether the pixels are live or stored from a file. Call before editing text you did not write, to get the ranges. Changes nothing.",
+    inputSchema: { type: "object", properties: { layerId: LAYER_ID6 }, required: ["layerId"], additionalProperties: false },
+    annotations: { title: "Read a type layer", ...READ9 },
+    handler: ({ layerId }) => controller.getTextLayer(typeId(layerId))
+  };
+  const add2 = {
+    name: "add_text_layer",
+    title: "Add a type layer",
+    description: "Adds a live type layer and makes it active: point text whose origin (x, y) is the first line\u2019s baseline at its alignment edge, or paragraph text wrapped in box {width, height} with its top-left at (x, y). Line breaks in text start paragraphs. Style and paragraph settings apply to the whole text (change ranges later with set_text_style). Default style: 24 px sans-serif in the foreground colour. One undo step. Returns the layer and the text layer, including missingFonts.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        text: { type: "string", description: "The text; \\n starts a new paragraph." },
+        x: { type: "number", description: "Document x of the origin, pixels." },
+        y: { type: "number", description: "Document y of the origin (point text: the first baseline), pixels." },
+        box: {
+          type: "object",
+          description: "Make it paragraph (area) text wrapped in this box, pixels.",
+          properties: { width: { type: "number", minimum: 1, description: "Box width, pixels." }, height: { type: "number", minimum: 1, description: "Box height, pixels." } },
+          required: ["width", "height"],
+          additionalProperties: false
+        },
+        style: { type: "object", description: "Character style.", properties: STYLE, additionalProperties: false },
+        paragraph: { type: "object", description: "Paragraph style.", properties: PARAGRAPH, additionalProperties: false },
+        rotation: { type: "number", description: "Degrees clockwise about the origin (default 0)." },
+        name: { type: "string", description: "Layer name (default the start of the text)." },
+        opacity: { type: "number", minimum: 0, maximum: 1, description: "Layer opacity 0..1 (default 1)." },
+        blend: { type: "string", enum: BLEND_MODES.map((m) => m.id), description: "Blend mode (default normal)." },
+        aboveId: { type: "string", description: "Put the layer directly above this layer (default above the active layer)." },
+        belowId: { type: "string", description: "Put the layer directly below this layer." },
+        parentId: { type: "string", description: "Put the layer inside this group." },
+        index: { type: "integer", minimum: 0, description: "Position among the siblings, 0 = bottom." }
+      },
+      required: ["text", "x", "y"],
+      additionalProperties: false
+    },
+    annotations: { title: "Add a type layer", ...WRITE8 },
+    handler: (args) => {
+      const init = pick(args, ["text", "x", "y", "box", "style", "paragraph", "rotation", "name", "opacity", "blend", "aboveId", "belowId", "parentId", "index"]);
+      if (init.blend !== void 0) init.blend = init.blend;
+      const id = controller.addTextLayer(init);
+      return { layer: layerSummary(id), text: controller.getTextLayer(id) };
+    }
+  };
+  const setText = {
+    name: "set_text",
+    title: "Edit text",
+    description: "Replaces the text in [start, end) (default all of it) with text; inserted text takes the style of the character at start. Use start = end to insert. Returns the text layer with its new runs.",
+    inputSchema: { type: "object", properties: { layerId: LAYER_ID6, text: { type: "string", description: "Replacement text (\\n starts a paragraph; empty deletes the range)." }, start: START, end: END }, required: ["layerId", "text"], additionalProperties: false },
+    annotations: { title: "Edit text", ...WRITE8 },
+    handler: (args) => controller.setText(typeId(args.layerId), args.text, range(args))
+  };
+  const setStyle = {
+    name: "set_text_style",
+    title: "Style a range of text",
+    description: "Sets character style fields (font, weight, italic, size, colour, tracking, leading, baseline shift, underline, strike-through) over [start, end) of a type layer (default all of it); fields not given keep their values per run. Returns the text layer with its runs and missingFonts.",
+    inputSchema: { type: "object", properties: { layerId: LAYER_ID6, start: START, end: END, ...STYLE }, required: ["layerId"], additionalProperties: false },
+    annotations: { title: "Style a range of text", ...WRITE_IDEMPOTENT6 },
+    handler: (args) => {
+      const style = pick(args, Object.keys(STYLE));
+      if (!Object.keys(style).length) throw new LayerOperationError(`Give at least one style field: ${Object.keys(STYLE).join(", ")}.`);
+      return controller.setTextStyle(typeId(args.layerId), style, range(args));
+    }
+  };
+  const setParagraph = {
+    name: "set_paragraph_style",
+    title: "Style paragraphs",
+    description: "Sets paragraph fields (alignment, auto leading, indents, spacing) on every paragraph that [start, end) touches (default all). Returns the text layer.",
+    inputSchema: { type: "object", properties: { layerId: LAYER_ID6, start: START, end: END, ...PARAGRAPH }, required: ["layerId"], additionalProperties: false },
+    annotations: { title: "Style paragraphs", ...WRITE_IDEMPOTENT6 },
+    handler: (args) => {
+      const style = pick(args, Object.keys(PARAGRAPH));
+      if (!Object.keys(style).length) throw new LayerOperationError(`Give at least one paragraph field: ${Object.keys(PARAGRAPH).join(", ")}.`);
+      return controller.setParagraphStyle(typeId(args.layerId), style, range(args));
+    }
+  };
+  const setFrame = {
+    name: "set_text_frame",
+    title: "Point or paragraph text",
+    description: "Converts between point text (kind point: one line per paragraph) and paragraph text (kind box: wrapped in width \xD7 height pixels, its top-left where the first line starts), or resizes a paragraph box. The first line stays in place. Returns the text layer with its new lines.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        layerId: LAYER_ID6,
+        kind: { type: "string", enum: ["point", "box"], description: "point or box." },
+        width: { type: "number", minimum: 1, description: "Box width in pixels (kind box)." },
+        height: { type: "number", minimum: 1, description: "Box height in pixels (kind box)." }
+      },
+      required: ["layerId", "kind"],
+      additionalProperties: false
+    },
+    annotations: { title: "Point or paragraph text", ...WRITE_IDEMPOTENT6 },
+    handler: ({ layerId, kind, width, height }) => {
+      const id = typeId(layerId);
+      if (kind === "box" && (width === void 0 || height === void 0)) throw new LayerOperationError("kind box needs width and height in pixels.");
+      return controller.setTextFrame(id, kind === "box" ? { kind: "box", width, height } : { kind: "point" });
+    }
+  };
+  const toShape = {
+    name: "convert_text_to_shape",
+    title: "Convert text to a shape",
+    description: "Type \u203A Convert to Shape: the text\u2019s glyph outlines become a shape layer (same id, name, mask, effects, opacity, blend) that can be edited with the shape tools; the text is no longer editable. Needs a font shaper that gives outlines (the browser\u2019s canvas cannot). The fill is the first run\u2019s colour. One undo step. Returns the layer and warnings.",
+    inputSchema: { type: "object", properties: { layerId: LAYER_ID6 }, required: ["layerId"], additionalProperties: false },
+    annotations: { title: "Convert text to a shape", ...DESTRUCTIVE7 },
+    handler: ({ layerId }) => {
+      const { layerId: id, warnings } = controller.convertTextToShape(typeId(layerId));
+      return { layer: layerSummary(id), shape: controller.getShapeLayer(id), warnings };
+    }
+  };
+  return [listFonts, get, add2, setText, setStyle, setParagraph, setFrame, toShape];
+}
+
 // src/image-editor/tools.ts
 var LAYER_PATH = /^layers\.([^.]+)\.(.+)$/;
 function adjustmentsSummary(adjustments) {
@@ -10259,6 +10983,7 @@ function createImageEditorToolProvider(controller, options = {}) {
       ...createImageTransformTools(controller),
       ...createImageSmartObjectTools(controller),
       ...createImageShapeTools(controller),
+      ...createImageTypeTools(controller),
       ...createImageEffectTools(controller),
       ...createImagePaintTools(controller),
       ...createPigmentTools(),
@@ -10561,6 +11286,470 @@ function applyRegionBlur(imageData, regions, radius = 10) {
   return imageData;
 }
 
+// src/image-editor/layers/shape-type-ui.ts
+var DEFAULT_SHAPE_TOOL_OPTIONS = {
+  kind: "rect",
+  fill: "#4f46e5",
+  stroke: null,
+  strokeWidth: 2,
+  radius: 0,
+  sides: 6,
+  points: 5,
+  innerRatio: 0.5,
+  weight: 4,
+  arrow: false
+};
+var SHAPE_KIND_LABELS = { rect: "Rectangle", ellipse: "Ellipse", polygon: "Polygon", star: "Star", line: "Line" };
+var DEFAULT_TYPE_TOOL_OPTIONS = { fontFamily: "sans-serif", fontSize: 32, fontWeight: 400, italic: false, color: "#111827", align: "left" };
+function liveShapeForDrag(o, a, b, mods = {}) {
+  if (o.kind === "line") {
+    let x2 = b.x;
+    let y2 = b.y;
+    if (mods.shift) {
+      const ang = Math.round(Math.atan2(b.y - a.y, b.x - a.x) / (Math.PI / 4)) * (Math.PI / 4);
+      const len = Math.hypot(b.x - a.x, b.y - a.y);
+      x2 = a.x + Math.cos(ang) * len;
+      y2 = a.y + Math.sin(ang) * len;
+    }
+    if (Math.hypot(x2 - a.x, y2 - a.y) < 1) return null;
+    const head = o.arrow ? { endArrow: { width: o.weight * 4, length: o.weight * 4 } } : {};
+    return { kind: "line", x1: a.x, y1: a.y, x2, y2, weight: o.weight, ...head };
+  }
+  let w = b.x - a.x;
+  let h = b.y - a.y;
+  if (mods.shift) {
+    const s = Math.max(Math.abs(w), Math.abs(h));
+    w = Math.sign(w || 1) * s;
+    h = Math.sign(h || 1) * s;
+  }
+  let x = a.x;
+  let y = a.y;
+  if (mods.alt) {
+    x = a.x - w;
+    y = a.y - h;
+    w *= 2;
+    h *= 2;
+  }
+  const box = { x: Math.min(x, x + w), y: Math.min(y, y + h), width: Math.abs(w), height: Math.abs(h) };
+  if (box.width < 1 || box.height < 1) return null;
+  switch (o.kind) {
+    case "rect":
+      return { kind: "rect", ...box, ...o.radius > 0 ? { radius: o.radius } : {} };
+    case "ellipse":
+      return { kind: "ellipse", ...box };
+    case "polygon":
+      return { kind: "polygon", ...box, sides: o.sides };
+    case "star":
+      return { kind: "star", ...box, points: o.points, innerRatio: o.innerRatio };
+  }
+  return null;
+}
+var ShapeDrawGesture = class {
+  constructor(controller, options) {
+    this.controller = controller;
+    this.options = options;
+  }
+  controller;
+  options;
+  start = null;
+  layerId = null;
+  error = null;
+  get active() {
+    return this.start !== null;
+  }
+  /** The shape layer drawn by the last drag (until the next one starts). */
+  get drawnLayerId() {
+    return this.layerId;
+  }
+  down(p) {
+    this.error = null;
+    this.start = { x: p.x, y: p.y };
+    this.layerId = null;
+  }
+  move(p, mods = {}) {
+    if (!this.start) return;
+    const o = this.options();
+    const shape = liveShapeForDrag(o, this.start, p, mods);
+    if (!shape) return;
+    try {
+      if (!this.layerId) {
+        const isLine = o.kind === "line";
+        this.layerId = this.controller.addShapeLayer({
+          shape,
+          fill: isLine ? o.stroke ?? o.fill ?? "#000000" : o.fill,
+          stroke: !isLine && o.stroke ? { width: o.strokeWidth, paint: o.stroke } : null
+        });
+      } else this.controller.setShapeComponent(this.layerId, 0, { shape }, false);
+    } catch (e) {
+      this.error = e instanceof Error ? e.message : String(e);
+      this.start = null;
+    }
+  }
+  up() {
+    this.start = null;
+    return this.layerId;
+  }
+  cancel() {
+    this.start = null;
+  }
+};
+function applyShapeOptions(controller, layerId, change) {
+  const info = controller.getShapeLayer(layerId);
+  const style = {};
+  if ("fill" in change) style.fill = change.fill ?? null;
+  if ("stroke" in change || "strokeWidth" in change) {
+    const color = "stroke" in change ? change.stroke : info.stroke?.paint.type === "color" ? info.stroke.paint.color : null;
+    style.stroke = color ? { width: change.strokeWidth ?? info.stroke?.width ?? 2, paint: color } : null;
+  }
+  if (Object.keys(style).length) controller.setShapeStyle(layerId, style);
+  const live = info.components[0]?.live;
+  if (!live) return;
+  const shape = {};
+  if (live.kind === "rect" && change.radius !== void 0) shape.radius = change.radius;
+  if (live.kind === "polygon" && change.sides !== void 0) shape.sides = change.sides;
+  if (live.kind === "star" && change.points !== void 0) shape.points = change.points;
+  if (live.kind === "star" && change.innerRatio !== void 0) shape.innerRatio = change.innerRatio;
+  if (live.kind === "line" && change.weight !== void 0) shape.weight = change.weight;
+  if (live.kind === "line" && change.arrow !== void 0) shape.endArrow = change.arrow ? { width: (live.weight || 1) * 4, length: (live.weight || 1) * 4 } : null;
+  if (Object.keys(shape).length) controller.setShapeComponent(layerId, 0, { shape });
+}
+var TextEditSession = class {
+  constructor(controller, layerId, index) {
+    this.controller = controller;
+    this.layerId = layerId;
+    const n = this.text.length;
+    this.anchor = this.focus = Math.max(0, Math.min(n, index ?? n));
+  }
+  controller;
+  layerId;
+  anchor;
+  focus;
+  changed = false;
+  listeners = /* @__PURE__ */ new Set();
+  error = null;
+  get layer() {
+    const l = findLayer(this.controller.getLayers(), this.layerId)?.layer;
+    if (!l || l.type !== "type") throw new Error("The type layer being edited is gone.");
+    return l;
+  }
+  get text() {
+    return this.layer.text;
+  }
+  get start() {
+    return Math.min(this.anchor, this.focus);
+  }
+  get end() {
+    return Math.max(this.anchor, this.focus);
+  }
+  /** Whether the layer still exists (it can be deleted or undone away while editing). */
+  get alive() {
+    return findLayer(this.controller.getLayers(), this.layerId)?.layer.type === "type";
+  }
+  subscribe(fn) {
+    this.listeners.add(fn);
+    return () => this.listeners.delete(fn);
+  }
+  emit() {
+    for (const l of this.listeners) l();
+  }
+  layout() {
+    return this.controller.getTextLayout(this.layerId);
+  }
+  run(fn) {
+    this.error = null;
+    try {
+      const out = fn(!this.changed);
+      this.changed = true;
+      return out;
+    } catch (e) {
+      this.error = e instanceof Error ? e.message : String(e);
+      return void 0;
+    } finally {
+      this.emit();
+    }
+  }
+  /** Replaces the selection with `text` (typing and pasting). */
+  insert(text) {
+    if (!text) return;
+    const s = this.start;
+    const e = this.end;
+    const done = this.run((commit) => this.controller.setText(this.layerId, text, { start: s, end: e }, commit));
+    if (done) this.anchor = this.focus = s + text.replace(/\r\n?/g, "\n").length;
+  }
+  /** Backspace: the selection, else the character before the caret. */
+  deleteBackward() {
+    if (this.start === this.end && this.start === 0) return;
+    const s = this.start === this.end ? Math.max(0, this.start - this.surrogate(this.start - 1, -1)) : this.start;
+    const e = this.end;
+    if (this.run((commit) => this.controller.setText(this.layerId, "", { start: s, end: e }, commit))) this.anchor = this.focus = s;
+  }
+  /** Delete: the selection, else the character after the caret. */
+  deleteForward() {
+    const n = this.text.length;
+    if (this.start === this.end && this.end >= n) return;
+    const s = this.start;
+    const e = this.start === this.end ? Math.min(n, this.end + this.surrogate(this.end, 1)) : this.end;
+    if (this.run((commit) => this.controller.setText(this.layerId, "", { start: s, end: e }, commit))) this.anchor = this.focus = s;
+  }
+  /** 2 when the code unit at `i` is half of a surrogate pair (moving `dir`), else 1. */
+  surrogate(i, dir) {
+    const t = this.text;
+    const c = t.charCodeAt(i);
+    if (dir < 0 && c >= 56320 && c <= 57343 && i > 0) return 2;
+    if (dir > 0 && c >= 55296 && c <= 56319 && i + 1 < t.length) return 2;
+    return 1;
+  }
+  /** Moves the caret (Shift extends the selection). */
+  move(to, extend = false) {
+    const n = this.text.length;
+    let f = this.focus;
+    const collapsedJump = !extend && this.start !== this.end;
+    if (to === "left") f = collapsedJump ? this.start : Math.max(0, f - this.surrogate(f - 1, -1));
+    else if (to === "right") f = collapsedJump ? this.end : Math.min(n, f + this.surrogate(f, 1));
+    else if (to === "start") f = 0;
+    else if (to === "finish") f = n;
+    else {
+      const layout = this.layout();
+      if (layout && layout.lines.length) {
+        const c = caretAt(layout, f);
+        const line = layout.lines[c.line];
+        if (to === "home") f = line.start;
+        else if (to === "end") {
+          const last = line.chars[line.chars.length - 1];
+          f = last ? Math.min(n, last.index + 1) : line.start;
+          if (last && this.text[last.index] === " " && c.line < layout.lines.length - 1) f = last.index;
+        } else {
+          const target = layout.lines[c.line + (to === "up" ? -1 : 1)];
+          if (!target) f = to === "up" ? 0 : n;
+          else {
+            const hit = target.chars.find((ch) => c.x < ch.x + ch.advance / 2);
+            const last = target.chars[target.chars.length - 1];
+            f = hit ? hit.index : last ? last.index + 1 : target.start;
+          }
+        }
+      }
+    }
+    this.focus = f;
+    if (!extend) this.anchor = f;
+    this.emit();
+  }
+  selectAll() {
+    this.anchor = 0;
+    this.focus = this.text.length;
+    this.emit();
+  }
+  /** Places the caret at a document point (Shift-click extends). */
+  pointAt(p, extend = false) {
+    this.focus = this.controller.textIndexAt(this.layerId, p);
+    if (!extend) this.anchor = this.focus;
+    this.emit();
+  }
+  /** Handles a key; returns `true` when it was the session's (the caller then prevents the default). */
+  handleKey(e) {
+    const mod2 = e.metaKey || e.ctrlKey;
+    if (mod2 && e.key.toLowerCase() === "a") {
+      this.selectAll();
+      return true;
+    }
+    switch (e.key) {
+      case "Backspace":
+        this.deleteBackward();
+        return true;
+      case "Delete":
+        this.deleteForward();
+        return true;
+      case "Enter":
+        this.insert("\n");
+        return true;
+      case "ArrowLeft":
+        this.move(mod2 ? "home" : "left", e.shiftKey);
+        return true;
+      case "ArrowRight":
+        this.move(mod2 ? "end" : "right", e.shiftKey);
+        return true;
+      case "ArrowUp":
+        this.move(mod2 ? "start" : "up", e.shiftKey);
+        return true;
+      case "ArrowDown":
+        this.move(mod2 ? "finish" : "down", e.shiftKey);
+        return true;
+      case "Home":
+        this.move("home", e.shiftKey);
+        return true;
+      case "End":
+        this.move("end", e.shiftKey);
+        return true;
+      case "Tab":
+        this.insert("	");
+        return true;
+    }
+    if (!mod2 && !e.altKey && e.key.length >= 1 && [...e.key].length === 1) {
+      this.insert(e.key);
+      return true;
+    }
+    return false;
+  }
+  /** Sets character style fields on the selection, or on the whole text when nothing is selected. */
+  setStyle(style) {
+    const s = this.start;
+    const e = this.end;
+    const range = s === e ? {} : { start: s, end: e };
+    this.run((commit) => this.controller.setTextStyle(this.layerId, style, range, commit));
+  }
+  /** Sets paragraph fields on the paragraphs the selection touches. */
+  setParagraph(style) {
+    const s = this.start;
+    const e = this.end;
+    this.run((commit) => this.controller.setParagraphStyle(this.layerId, style, { start: s, end: e }, commit));
+  }
+  /** The style at the caret (or the selection's start), for the options bar. */
+  styleHere() {
+    const layer = this.layer;
+    const at = this.start > 0 && this.start === this.end ? this.start - 1 : this.start;
+    return styleAt(layer.runs, at, DEFAULT_TEXT_STYLE);
+  }
+  info() {
+    return this.controller.getTextLayer(this.layerId);
+  }
+  /** The caret, the selection and the frame in natural pixels, for `RenderOptions.textEdit`. */
+  overlay() {
+    const layer = this.layer;
+    const layout = this.layout();
+    const m = textMatrix(layer);
+    const at = (x, y) => applyMatrix(m, { x, y });
+    let frame = null;
+    if (layer.frame.kind === "box") frame = [at(0, 0), at(layer.frame.width, 0), at(layer.frame.width, layer.frame.height), at(0, layer.frame.height)];
+    else if (layout) {
+      const b = layout.bounds;
+      frame = [at(b.x, b.y), at(b.x + b.width, b.y), at(b.x + b.width, b.y + b.height), at(b.x, b.y + b.height)];
+    }
+    if (!layout) return { caret: null, selection: [], frame };
+    const selection = [];
+    if (this.start !== this.end) {
+      for (const l of layout.lines) {
+        const chars = l.chars.filter((c2) => c2.index >= this.start && c2.index < this.end);
+        if (!chars.length) continue;
+        const x0 = chars[0].x;
+        const x1 = chars[chars.length - 1].x + chars[chars.length - 1].advance;
+        const top = l.baseline - l.ascent;
+        const bottom = l.baseline + l.descent;
+        selection.push([at(x0, top), at(x1, top), at(x1, bottom), at(x0, bottom)]);
+      }
+    }
+    const c = caretAt(layout, this.focus);
+    return { caret: [at(c.x, c.top), at(c.x, c.bottom)], selection, frame };
+  }
+  /** Ends editing: an empty layer made for this session is deleted (as Photoshop does). Returns whether the layer remains. */
+  close() {
+    if (!this.alive) return false;
+    if (!this.text.trim().length) {
+      try {
+        this.controller.removeLayer(this.layerId);
+      } catch {
+      }
+      return false;
+    }
+    if (this.layer.name === "Text" && this.changed) {
+      try {
+        this.controller.setLayerProperties(this.layerId, { name: typeLayerName(this.text) }, false);
+      } catch {
+      }
+    }
+    return true;
+  }
+};
+function typeLayerAt(controller, p, slop = 4) {
+  const layers = [...flattenTypeLayers(controller.getLayers())].reverse();
+  for (const l of layers) {
+    if (!l.visible) continue;
+    const inv = invert(textMatrix(l));
+    const q = applyMatrix(inv, p);
+    let b = null;
+    if (l.frame.kind === "box") b = { x: 0, y: 0, width: l.frame.width, height: l.frame.height };
+    else {
+      const layout = controller.getTextLayout(l.id);
+      if (layout) b = layout.bounds;
+    }
+    if (b && q.x >= b.x - slop && q.x <= b.x + b.width + slop && q.y >= b.y - slop && q.y <= b.y + b.height + slop) return l.id;
+  }
+  return null;
+}
+function flattenTypeLayers(layers) {
+  const out = [];
+  const walk = (list) => {
+    for (const l of list) {
+      if (l.type === "type") out.push(l);
+      else if (l.type === "group") walk(l.children);
+    }
+  };
+  walk(layers);
+  return out;
+}
+function invert(m) {
+  const [a, b, c, d, e, f] = m;
+  const det = a * d - b * c || 1;
+  return [d / det, -b / det, -c / det, a / det, (c * f - d * e) / det, (b * e - a * f) / det];
+}
+var TypeToolGesture = class {
+  constructor(controller, options) {
+    this.controller = controller;
+    this.options = options;
+  }
+  controller;
+  options;
+  session = null;
+  dragStart = null;
+  error = null;
+  down(p, mods = {}) {
+    this.error = null;
+    const hit = typeLayerAt(this.controller, p);
+    if (this.session && this.session.alive && hit === this.session.layerId) {
+      this.session.pointAt(p, mods.shift);
+      this.dragStart = null;
+      return;
+    }
+    this.finish();
+    if (hit) {
+      this.controller.setActiveLayer(hit);
+      this.session = new TextEditSession(this.controller, hit, this.controller.textIndexAt(hit, p));
+      this.dragStart = null;
+      return;
+    }
+    this.dragStart = { x: p.x, y: p.y };
+  }
+  /** Releases a click or drag that did not land on type: adds a new text layer (point text, or a box for a drag). */
+  up(p) {
+    const start = this.dragStart;
+    this.dragStart = null;
+    if (!start) return this.session;
+    const o = this.options();
+    const w = Math.abs(p.x - start.x);
+    const h = Math.abs(p.y - start.y);
+    try {
+      const box = w >= 8 && h >= 8 ? { width: w, height: h } : void 0;
+      const id = this.controller.addTextLayer({
+        text: "",
+        x: box ? Math.min(start.x, p.x) : start.x,
+        y: box ? Math.min(start.y, p.y) : start.y,
+        ...box ? { box } : {},
+        style: { fontFamily: o.fontFamily, fontSize: o.fontSize, fontWeight: o.fontWeight, italic: o.italic, color: o.color },
+        paragraph: o.align !== "left" ? { align: o.align } : {},
+        name: "Text"
+      });
+      this.session = new TextEditSession(this.controller, id, 0);
+    } catch (e) {
+      this.error = e instanceof Error ? e.message : String(e);
+    }
+    return this.session;
+  }
+  /** Ends the open session (an empty new layer is removed). */
+  finish() {
+    const s = this.session;
+    this.session = null;
+    s?.close();
+  }
+};
+
 // src/image-editor/layers/panel.ts
 function layerPanelRows(layers, activeId) {
   const rows = [];
@@ -10601,7 +11790,18 @@ function layerBadge(layer) {
       return "so";
     case "shape":
       return "shp";
+    case "type":
+      return "T";
+  }
+}
+function layerHasThumbnail(layer) {
+  return layer.type === "pixel" || layer.type === "shape" || layer.type === "type";
+}
+function layerWarning(layer) {
+  if (layer.type === "type" && layer.missingFonts?.length) {
+    return `Missing ${layer.missingFonts.length === 1 ? "font" : "fonts"}: ${layer.missingFonts.join(", ")}. ${layer.rendering === "stored" ? "Showing the saved pixels until the text is edited." : "Drawn with a fallback font."}`;
   }
+  return null;
 }
 function dropZone(fraction, isGroup) {
   if (isGroup && fraction > 0.3 && fraction < 0.7) return "inside";
@@ -10640,7 +11840,7 @@ function layerMenu(controller) {
     { action: "delete-mask", label: "Delete Layer Mask", enabled: Boolean(active?.mask) },
     { action: "toggle-mask", label: active?.mask?.enabled === false ? "Enable Layer Mask" : "Disable Layer Mask", enabled: Boolean(active?.mask) },
     { action: "toggle-mask-link", label: active?.mask?.linked === false ? "Link Layer Mask" : "Unlink Layer Mask", enabled: Boolean(active?.mask && !active.mask.source) },
-    { action: "rasterize", label: "Rasterize Layer", enabled: active?.type === "annotation" || active?.type === "smart" || active?.type === "shape" || isPixel && Boolean(active?.type === "pixel" && active.filters?.length) },
+    { action: "rasterize", label: "Rasterize Layer", enabled: active?.type === "annotation" || active?.type === "smart" || active?.type === "shape" || active?.type === "type" || isPixel && Boolean(active?.type === "pixel" && active.filters?.length) },
     { action: "convert-smart", label: "Convert to Smart Object", enabled: Boolean(active && active.type !== "annotation") },
     { action: "edit-contents", label: "Edit Contents", enabled: active?.type === "smart" },
     { action: "smart-via-copy", label: "New Smart Object via Copy", enabled: active?.type === "smart" },
@@ -11573,6 +12773,7 @@ export {
   D50,
   D65,
   DEFAULT_ADJUSTMENTS,
+  DEFAULT_AUTO_LEADING,
   DEFAULT_BLENDER,
   DEFAULT_BRUSH,
   DEFAULT_DEPTH_MASK,
@@ -11581,8 +12782,11 @@ export {
   DEFAULT_MIXER,
   DEFAULT_REFINE_EDGE_PARAMS,
   DEFAULT_SELECTION_TOOL_OPTIONS,
+  DEFAULT_SHAPE_TOOL_OPTIONS,
   DEFAULT_SMUDGE,
+  DEFAULT_TEXT_STYLE,
   DEFAULT_TRANSFORM,
+  DEFAULT_TYPE_TOOL_OPTIONS,
   DEPTH_MASK_CONTROLS,
   DEVELOP_FILTER_ID,
   DIRECT_GAUSSIAN_MAX_SIGMA,
@@ -11631,6 +12835,7 @@ export {
   MixerStroke,
   PAINTERLY_BLEND_MODES,
   PAINT_TOOLS,
+  PARAGRAPH_STYLE_FIELDS,
   PATTERN_BLOCK_KEYS,
   PIGMENT_BANDS,
   PIGMENT_LAMBDA_MIN,
@@ -11650,23 +12855,30 @@ export {
   SELECTION_MODIFY_OPS,
   SELECTION_TOOLS,
   SHADOW_AMBIENT,
+  SHAPE_KIND_LABELS,
   SHAPE_OPERATIONS,
   SHAPE_RENDER_MARGIN,
   SMART_RENDER_MARGIN,
   SUPPORTED_ADJUSTMENT_KEYS,
   SelectionGesture,
+  ShapeDrawGesture,
   SmudgeTip,
   StrokeCoverage,
   SurfaceDraft,
+  TEXT_ALIGNS,
+  TEXT_RENDER_MARGIN,
+  TEXT_STYLE_FIELDS,
   TILE,
   TILE_SHIFT,
   TINT_SCALE,
   TONE_LUT_SIZE,
   TONE_RANGE_PRESETS,
   TRANSFORM_ANCHORS,
+  TextEditSession,
   TileMedium,
   TiledSurface,
   TransformTooLargeError,
+  TypeToolGesture,
   VIBRANCE_GREY,
   WARP_GRID_OPTIONS,
   WARP_STYLES,
@@ -11691,6 +12903,7 @@ export {
   annotationLayerName,
   annotationOfLayer,
   annotationOfShape,
+  annotationOfType,
   applyAdjustmentLayers,
   applyAdjustments,
   applyBoxBlur,
@@ -11704,6 +12917,7 @@ export {
   applyProcess2Adjustments,
   applyRegionBlur,
   applyRegionMosaic,
+  applyShapeOptions,
   applySmartFilters,
   applyStrokeToTile,
   backgroundLayer,
@@ -11733,6 +12947,7 @@ export {
   calculateCropDrag,
   canvasCompositeOperation,
   canvasToImagePoint,
+  caretAt,
   changedTiles,
   clampControlValue,
   clampCropToImage,
@@ -11760,6 +12975,7 @@ export {
   coveringRect,
   createAdjustmentLayer,
   createBlenderScratch,
+  createCanvasTextShaper,
   createImageCaptureSurface,
   createImageEditTools,
   createImageEditorToolProvider,
@@ -11771,10 +12987,15 @@ export {
   createImageShapeTools,
   createImageSmartObjectTools,
   createImageTransformTools,
+  createImageTypeTools,
+  createOutlineTextShaper,
   createPigment,
   createPigmentTools,
   createSelectionMask,
   createShapeLayer,
+  createTypeLayer,
+  cssFont,
+  cssFontFamily,
   curveLut,
   curveLutFromLevels,
   curvePointToBox,
@@ -11843,9 +13064,12 @@ export {
   findLayer,
   findLayerControl,
   finishTile,
+  fitParagraphRuns,
+  fitRuns,
   flattenLayers,
   flattenPath,
   flipCorners,
+  fontOf,
   formatControlValue,
   fullSelection,
   gaussianBlur,
@@ -11926,6 +13150,7 @@ export {
   layerEffectsBadge,
   layerEffectsOf,
   layerEffectsPanel,
+  layerHasThumbnail,
   layerLabel,
   layerMaskCoverage,
   layerMaskFromSelection,
@@ -11935,7 +13160,9 @@ export {
   layerPanelRows,
   layerTree,
   layerTypeLabel,
+  layerWarning,
   layersFromLegacy,
+  layoutText,
   legacyAdjustmentLayer,
   legacyMaskOf,
   legacyView,
@@ -11945,6 +13172,7 @@ export {
   linearSrgbToXy,
   linearToSrgb,
   liveComponent,
+  liveShapeForDrag,
   liveShapeSubpaths,
   loadImageEditorDocument,
   loadMixer,
@@ -11995,11 +13223,13 @@ export {
   normalizeSmudge,
   normalizeStoredAdjustments,
   normalizeSubpaths,
+  normalizeText,
   offsetLayer,
   offsetShape,
   offsetSmartObject,
   openPsdFile,
   packRgba,
+  paragraphRanges,
   parseAdjustmentBlock,
   parseBlend,
   parseColor,
@@ -12011,6 +13241,8 @@ export {
   parsePatternBlock,
   parseSelectionMode,
   parseVersionedDescriptor,
+  patchParagraphStyle,
+  patchTextStyle,
   photoFilterMatrix,
   pigment8,
   pixelLayerBounds,
@@ -12066,19 +13298,24 @@ export {
   renderShape,
   renderShapeRect,
   renderSmartObject,
+  renderText,
   replaceContents,
+  replaceTextRange,
   requireLayer,
   requireOperation,
   requireShapeLayer,
   requireSmartObject,
+  requireTypeLayer,
   requireUnlocked,
   rerender,
   rerenderShape,
+  rerenderText,
   resizePixels,
   resizeSelection,
   resizeWarpMesh,
   resolveExternalAssets,
   resolveMosaicRegionBounds,
+  restyleRange,
   rgbToGray,
   rgbToHsl,
   rgbToReflectance,
@@ -12125,16 +13362,22 @@ export {
   smoothCoverage,
   smoothPoints,
   solidSurface,
+  spliceRuns,
   splitOverlayAnnotations,
   srgb8ToLab,
   srgbToLinear,
   standardBlendMode,
+  styleAt,
   sumHistograms,
   surfaceBytes,
   surfaceFromPixels,
   surfacesEqual,
   tempTintToXy,
   temperatureToKelvin,
+  textIndexAt,
+  textMatrix,
+  textOutlines,
+  textRange,
   tileCoord,
   tileKey,
   tileRect,
@@ -12143,6 +13386,7 @@ export {
   tipReach,
   tipShape,
   toHex,
+  toTextSpace,
   toneCurve,
   toneLuts,
   toneRange,
@@ -12150,10 +13394,16 @@ export {
   transformMap,
   transformShapeComponents,
   transformSurface,
+  transformTypeLayer,
   transformedBounds,
   transformedBox,
   transformedPoint,
   translateSurface,
+  typeAsPixelLayer,
+  typeFrame,
+  typeFromAnnotation,
+  typeLayerAt,
+  typeLayerName,
   ungroupLayer,
   uniformTile,
   unionRect,
@@ -12163,6 +13413,7 @@ export {
   updateLayerMaskProps,
   updateShapeLayer,
   updateSmartFilter,
+  updateTypeLayer,
   uvToXy,
   validateEffectGradient,
   validateLayerEffect,