@pixerate/editor 0.260.0 → 0.262.0

package/dist/{chunk-UCYW4M66.js → chunk-ZQI3WUPP.js}

@@ -1,6 +1,6 @@
 import {
   parseSkillFrontmatter
-} from "./chunk-ABHOYBZD.js";
+} from "./chunk-K4BGRCSH.js";
 import {
   readingTime
 } from "./chunk-EHTX34RE.js";
@@ -596,6 +596,160 @@ function createOriginMiddleware(options) {
   };
 }
 
+// src/tools/conformance.ts
+var ConformanceIds = class {
+  toPlaceholder = /* @__PURE__ */ new Map();
+  fromPlaceholder = /* @__PURE__ */ new Map();
+  /** The placeholder for `id`, assigning the next one when it is new. */
+  add(id) {
+    let placeholder = this.toPlaceholder.get(id);
+    if (!placeholder) {
+      placeholder = `@${this.toPlaceholder.size + 1}`;
+      this.toPlaceholder.set(id, placeholder);
+      this.fromPlaceholder.set(placeholder, id);
+    }
+    return placeholder;
+  }
+  placeholder(id) {
+    return this.toPlaceholder.get(id);
+  }
+  /** `text` with every known id in it replaced by its placeholder (longest ids first). */
+  replaceWithin(text) {
+    const exact = this.toPlaceholder.get(text);
+    if (exact) return exact;
+    let out = text;
+    for (const id of [...this.toPlaceholder.keys()].sort((a, b) => b.length - a.length)) {
+      if (out.includes(id)) out = out.split(id).join(this.toPlaceholder.get(id));
+    }
+    return out;
+  }
+  /** The real id a placeholder stands for. */
+  resolve(placeholder) {
+    return this.fromPlaceholder.get(placeholder);
+  }
+};
+var PLACEHOLDER = /^@[1-9][0-9]*$/;
+var TIMESTAMP = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?(Z|[+-]\d{2}:\d{2})$/;
+var BASE64 = /^[A-Za-z0-9+/=_-]+$/;
+var CONFORMANCE_BINARY_MIN_LENGTH = 200;
+function isBinary(value) {
+  return value.startsWith("data:") || value.length >= CONFORMANCE_BINARY_MIN_LENGTH && BASE64.test(value);
+}
+function sortedKeys(value) {
+  return Object.keys(value).sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
+}
+function collectIds(value, ids, isId) {
+  if (typeof value === "string") {
+    if (isId(value)) ids.add(value);
+    return;
+  }
+  if (Array.isArray(value)) {
+    for (const item of value) collectIds(item, ids, isId);
+    return;
+  }
+  if (value && typeof value === "object") {
+    for (const k of sortedKeys(value)) {
+      if (isId(k)) ids.add(k);
+      collectIds(value[k], ids, isId);
+    }
+  }
+}
+function replaceIds(value, ids) {
+  if (typeof value === "string") return isBinary(value) ? "<binary>" : TIMESTAMP.test(value) ? "<time>" : ids.replaceWithin(value);
+  if (Array.isArray(value)) return value.map((item) => replaceIds(item, ids));
+  if (value && typeof value === "object") {
+    const out = {};
+    for (const k of sortedKeys(value)) out[ids.replaceWithin(k)] = replaceIds(value[k], ids);
+    return out;
+  }
+  return value;
+}
+function normalizeConformanceValue(value, ids, isGeneratedId = () => false) {
+  const json = value === void 0 ? null : JSON.parse(JSON.stringify(value));
+  collectIds(json, ids, (v) => !PLACEHOLDER.test(v) && isGeneratedId(v));
+  return replaceIds(json, ids);
+}
+function omitConformancePaths(value, paths) {
+  let out = value === void 0 ? null : JSON.parse(JSON.stringify(value));
+  for (const path of paths) out = omitPath(out, path.split("/").slice(1));
+  return out;
+}
+function omitPath(value, parts) {
+  if (!value || typeof value !== "object" || parts.length === 0) return value;
+  const [head, ...rest] = parts;
+  if (Array.isArray(value)) {
+    if (head === "*") return value.map((item) => omitPath(item, rest));
+    const i = Number(head);
+    if (!Number.isInteger(i) || i < 0 || i >= value.length) return value;
+    if (rest.length === 0) return value.filter((_, j) => j !== i);
+    return value.map((item, j) => j === i ? omitPath(item, rest) : item);
+  }
+  const object = value;
+  const keys = head === "*" ? Object.keys(object) : head in object ? [head] : [];
+  for (const key of keys) {
+    if (rest.length === 0) delete object[key];
+    else object[key] = omitPath(object[key], rest);
+  }
+  return object;
+}
+function resolveConformanceArguments(value, ids) {
+  if (typeof value === "string" && PLACEHOLDER.test(value)) {
+    const id = ids.resolve(value);
+    if (id === void 0) throw new Error(`Placeholder ${value} is used before any result returned that id.`);
+    return id;
+  }
+  if (Array.isArray(value)) return value.map((item) => resolveConformanceArguments(item, ids));
+  if (value && typeof value === "object") {
+    const out = {};
+    for (const [k, v] of Object.entries(value)) out[k] = resolveConformanceArguments(v, ids);
+    return out;
+  }
+  return value;
+}
+function conformanceResult(result) {
+  if (result.isError) {
+    const error = result.structuredContent?.error ?? {};
+    const value = { code: error.code ?? "tool_failed", message: error.message ?? resultText(result) ?? "", ...error.details !== void 0 ? { details: error.details } : {} };
+    return { value: { error: value }, isError: true };
+  }
+  if (result.structuredContent !== void 0) return { value: result.structuredContent, isError: false };
+  const text = resultText(result);
+  if (text === void 0) return { value: null, isError: false };
+  try {
+    return { value: JSON.parse(text), isError: false };
+  } catch {
+    return { value: text, isError: false };
+  }
+}
+function resultText(result) {
+  for (const content of result.content) {
+    if (content.type === "text" && "text" in content && typeof content.text === "string") return content.text;
+  }
+  return void 0;
+}
+async function runConformanceScenario(scenario, host) {
+  const ids = new ConformanceIds();
+  const isId = host.isGeneratedId?.bind(host);
+  const outputs = [];
+  try {
+    for (const step of scenario.steps) {
+      const args = resolveConformanceArguments(step.arguments ?? {}, ids);
+      const { value, isError } = conformanceResult(await host.callTool(step.tool, args));
+      const result = normalizeConformanceValue(value, ids, isId);
+      const output = { result: step.ignore ? omitConformancePaths(result, step.ignore) : result, isError };
+      if (step.document) output.document = normalizeConformanceValue(host.document(), ids, isId);
+      if (step.pixels) {
+        const image = host.pixels({ paper: typeof step.pixels === "object" ? step.pixels.paper : void 0 });
+        output.pixels = { width: image.width, height: image.height, data: new Uint8Array(image.data.buffer, image.data.byteOffset, image.data.byteLength) };
+      }
+      outputs.push(output);
+    }
+  } finally {
+    host.dispose?.();
+  }
+  return outputs;
+}
+
 export {
   listSkillEvals,
   imageEvalFixturePixels,
@@ -611,5 +765,12 @@ export {
   runStyleChecks,
   renderStyle,
   createStyleToolProvider,
-  createOriginMiddleware
+  createOriginMiddleware,
+  ConformanceIds,
+  CONFORMANCE_BINARY_MIN_LENGTH,
+  normalizeConformanceValue,
+  omitConformancePaths,
+  resolveConformanceArguments,
+  conformanceResult,
+  runConformanceScenario
 };

package/dist/paint-editor/contract.d.cts

@@ -9,7 +9,9 @@
  * package version, so a release does not change the files.
  */
 import type { EffectProvider } from '../effects/types.cjs';
+import type { ConformanceHost } from '../tools/conformance.cjs';
 import type { JsonSchema } from '../tools/schema.cjs';
+import { type PaintEditorOptions } from './controller.cjs';
 /** Bumped when a contract file changes shape (not when its data changes). */
 export declare const PAINT_CONTRACT_FORMAT_VERSION = 1;
 /**
@@ -27,3 +29,12 @@ export declare const PAINT_DOCUMENT_JSON_SCHEMA: JsonSchema;
 export declare function paintContracts(options: {
     effects: EffectProvider;
 }): Record<string, unknown>;
+/**
+ * A fresh paint editor for replaying a conformance scenario (`domains/paint/fixtures`): every paint
+ * tool provider in one registry that validates arguments, the saved document (the
+ * `pixerate.editor-document` envelope) and the composited pixels. `setup` is the scenario's
+ * editor options, such as `{ width, height }`; `effects` is the effect provider the effect tools use.
+ */
+export declare function createPaintConformanceHost(setup: PaintEditorOptions, options: {
+    effects: EffectProvider;
+}): ConformanceHost;

package/dist/paint-editor/contract.d.ts

@@ -9,7 +9,9 @@
  * package version, so a release does not change the files.
  */
 import type { EffectProvider } from '../effects/types.js';
+import type { ConformanceHost } from '../tools/conformance.js';
 import type { JsonSchema } from '../tools/schema.js';
+import { type PaintEditorOptions } from './controller.js';
 /** Bumped when a contract file changes shape (not when its data changes). */
 export declare const PAINT_CONTRACT_FORMAT_VERSION = 1;
 /**
@@ -27,3 +29,12 @@ export declare const PAINT_DOCUMENT_JSON_SCHEMA: JsonSchema;
 export declare function paintContracts(options: {
     effects: EffectProvider;
 }): Record<string, unknown>;
+/**
+ * A fresh paint editor for replaying a conformance scenario (`domains/paint/fixtures`): every paint
+ * tool provider in one registry that validates arguments, the saved document (the
+ * `pixerate.editor-document` envelope) and the composited pixels. `setup` is the scenario's
+ * editor options, such as `{ width, height }`; `effects` is the effect provider the effect tools use.
+ */
+export declare function createPaintConformanceHost(setup: PaintEditorOptions, options: {
+    effects: EffectProvider;
+}): ConformanceHost;

package/dist/paint-editor/controller.d.cts

@@ -26,6 +26,7 @@ import type { ColorScheme } from '../color/dual.cjs';
 import { type PaintCanvas, type PaintDocumentState, type PaintLayer } from './document.cjs';
 import { type ImageEncoder, type ImageFormat } from './encode.cjs';
 import type { PenPoint } from './engine.cjs';
+import { type PathSampleOptions } from './path-samples.cjs';
 import type { Hand } from './input.cjs';
 import { type PaperSettings } from './paper.cjs';
 import { type ViewLayer } from './render.cjs';
@@ -945,6 +946,22 @@ export declare class PaintEditorController {
     paintStroke(init: PaintStrokeInit & {
         points: readonly PenPoint[];
     }): PaintStrokeResult;
+    /**
+     * Brushes vector path data (SVG `d`, document pixels) with the active brush, or `brushId` /
+     * `brush`, as if drawn by hand: one recorded stroke per subpath, sampled every `spacing` px
+     * with an optional `pressure` profile along each. All of it is one undo step. A given `seed`
+     * seeds the first subpath; the next ones take the following seeds.
+     */
+    strokePath(init: Omit<PaintStrokeInit, 'start' | 'copies' | 'load'> & PathSampleOptions & {
+        path: string;
+    }): {
+        layerId: string;
+        bounds: RasterRect | null;
+        dabs: number;
+        strokeIds: string[];
+        mixerLoad?: MixerLoad;
+        wet?: boolean;
+    };
     /** Checks stroke samples (finite x and y, pressure 0..1) and returns them; throws a sentence naming the bad point. */
     checkPoints(points: readonly PenPoint[]): PenPoint[];
     /** Every recorded stroke, oldest first. */

package/dist/paint-editor/controller.d.ts

@@ -26,6 +26,7 @@ import type { ColorScheme } from '../color/dual.js';
 import { type PaintCanvas, type PaintDocumentState, type PaintLayer } from './document.js';
 import { type ImageEncoder, type ImageFormat } from './encode.js';
 import type { PenPoint } from './engine.js';
+import { type PathSampleOptions } from './path-samples.js';
 import type { Hand } from './input.js';
 import { type PaperSettings } from './paper.js';
 import { type ViewLayer } from './render.js';
@@ -945,6 +946,22 @@ export declare class PaintEditorController {
     paintStroke(init: PaintStrokeInit & {
         points: readonly PenPoint[];
     }): PaintStrokeResult;
+    /**
+     * Brushes vector path data (SVG `d`, document pixels) with the active brush, or `brushId` /
+     * `brush`, as if drawn by hand: one recorded stroke per subpath, sampled every `spacing` px
+     * with an optional `pressure` profile along each. All of it is one undo step. A given `seed`
+     * seeds the first subpath; the next ones take the following seeds.
+     */
+    strokePath(init: Omit<PaintStrokeInit, 'start' | 'copies' | 'load'> & PathSampleOptions & {
+        path: string;
+    }): {
+        layerId: string;
+        bounds: RasterRect | null;
+        dabs: number;
+        strokeIds: string[];
+        mixerLoad?: MixerLoad;
+        wet?: boolean;
+    };
     /** Checks stroke samples (finite x and y, pressure 0..1) and returns them; throws a sentence naming the bad point. */
     checkPoints(points: readonly PenPoint[]): PenPoint[];
     /** Every recorded stroke, oldest first. */