@inneranimalmedia/agentsam-sdk 2.6.10 → 2.6.11

package/packages/agentsam-merch/src/transforms.js

@@ -0,0 +1,215 @@
+import {
+  COMPATIBILITY_STATUS,
+  evaluateManufacturingCompatibility,
+} from "./compatibility.js";
+import { normalizeManufacturingProfile } from "./profile.js";
+
+export const TRANSFORM_OPERATION = Object.freeze({
+  TRIM_ALPHA: "trim_alpha",
+  NORMALIZE_COLOR_SPACE: "normalize_color_space",
+  NORMALIZE_SVG: "normalize_svg",
+  OUTLINE_TEXT: "outline_text",
+  VECTORIZER: "vectorize_monochrome",
+  RASTERIZE: "rasterize",
+  LOSSLESS_OPTIMIZE: "lossless_optimize",
+  CONVERT_FORMAT: "convert_format",
+  CONVERT_MONOCHROME: "convert_monochrome",
+});
+
+function operationFromAction(action, issue, profile) {
+  if (!action) return null;
+  if (action === "trim_alpha") {
+    return {
+      id: TRANSFORM_OPERATION.TRIM_ALPHA,
+      automatic: true,
+      requires: ["raster_normalizer"],
+      params: {},
+    };
+  }
+  if (action.startsWith("normalize_color_space:")) {
+    return {
+      id: TRANSFORM_OPERATION.NORMALIZE_COLOR_SPACE,
+      automatic: true,
+      requires: ["raster_normalizer"],
+      params: { colorSpace: action.split(":")[1] || profile.colorSpace || "srgb" },
+    };
+  }
+  if (action === "normalize_svg") {
+    return {
+      id: TRANSFORM_OPERATION.NORMALIZE_SVG,
+      automatic: true,
+      requires: ["svg_normalizer"],
+      params: { requireViewBox: true },
+    };
+  }
+  if (action === "outline_text") {
+    return {
+      id: TRANSFORM_OPERATION.OUTLINE_TEXT,
+      automatic: true,
+      requires: ["text_outliner"],
+      params: {},
+      note:
+        "SVGO does not convert fonts to paths by itself; outlining requires a font-aware vector executor.",
+    };
+  }
+  if (action === "vectorize_monochrome") {
+    return {
+      id: TRANSFORM_OPERATION.VECTORIZER,
+      automatic: true,
+      requires: ["vector_tracer", "raster_normalizer"],
+      params: {
+        tracer: issue?.meta?.preferredTracer || profile.vectorization.preferredTracer || "auto",
+        outputFormat: profile.vectorization.outputFormat || "svg",
+        maxAspectDrift: profile.vectorization.maxAspectDrift,
+        minBoundaryIntegrity: profile.vectorization.minBoundaryIntegrity,
+      },
+    };
+  }
+  if (action.startsWith("rasterize:")) {
+    return {
+      id: TRANSFORM_OPERATION.RASTERIZE,
+      automatic: true,
+      requires: ["vector_rasterizer"],
+      params: { format: action.split(":")[1] || profile.format },
+    };
+  }
+  if (action === "lossless_optimize") {
+    return {
+      id: TRANSFORM_OPERATION.LOSSLESS_OPTIMIZE,
+      automatic: true,
+      requires: ["raster_normalizer"],
+      params: { format: profile.format },
+    };
+  }
+  if (action.startsWith("convert:")) {
+    return {
+      id: TRANSFORM_OPERATION.CONVERT_FORMAT,
+      automatic: true,
+      requires: ["format_converter"],
+      params: { format: action.split(":")[1] || profile.format },
+    };
+  }
+  if (action === "convert_monochrome") {
+    return {
+      id: TRANSFORM_OPERATION.CONVERT_MONOCHROME,
+      automatic: true,
+      requires: ["vector_normalizer"],
+      params: {},
+    };
+  }
+  return {
+    id: action,
+    automatic: false,
+    requires: [],
+    params: {},
+  };
+}
+
+export function planAutomaticTransforms({
+  asset,
+  profile: profileInput,
+  target = {},
+  capabilities = {},
+} = {}) {
+  const profile = normalizeManufacturingProfile(profileInput);
+  const compatibility = evaluateManufacturingCompatibility(asset, profile, target);
+  const operations = [];
+  const seen = new Set();
+
+  for (const issue of compatibility.issues) {
+    const operation = operationFromAction(issue.action, issue, profile);
+    if (!operation || seen.has(operation.id)) continue;
+    seen.add(operation.id);
+    const missingCapabilities = operation.requires.filter(
+      (capability) => capabilities[capability] !== true,
+    );
+    operations.push(
+      Object.freeze({
+        ...operation,
+        issueCode: issue.code,
+        missingCapabilities: Object.freeze(missingCapabilities),
+        executable:
+          operation.automatic === true && missingCapabilities.length === 0,
+      }),
+    );
+  }
+
+  const blockingIssue = compatibility.issues.find(
+    (issue) =>
+      issue.status === COMPATIBILITY_STATUS.NEEDS_VARIANT ||
+      issue.status === COMPATIBILITY_STATUS.UNSUPPORTED,
+  );
+  const allRequiredExecutable = operations
+    .filter((operation) => operation.automatic)
+    .every((operation) => operation.executable);
+
+  return Object.freeze({
+    compatibility,
+    operations: Object.freeze(operations),
+    canExecuteAutomatically:
+      !blockingIssue && operations.length > 0 && allRequiredExecutable,
+    hasBlockingIssue: Boolean(blockingIssue),
+  });
+}
+
+function ratio(width, height) {
+  const w = Number(width);
+  const h = Number(height);
+  return Number.isFinite(w) && Number.isFinite(h) && w > 0 && h > 0
+    ? w / h
+    : null;
+}
+
+export function verifyVectorizationResult({
+  source,
+  result,
+  profile: profileInput,
+} = {}) {
+  const profile = normalizeManufacturingProfile(profileInput);
+  const sourceRatio = ratio(
+    source?.contentWidthPx || source?.widthPx || source?.width,
+    source?.contentHeightPx || source?.heightPx || source?.height,
+  );
+  const resultRatio = ratio(
+    result?.contentWidthPx || result?.widthPx || result?.width,
+    result?.contentHeightPx || result?.heightPx || result?.height,
+  );
+
+  const aspectDrift =
+    sourceRatio && resultRatio
+      ? Math.abs(resultRatio - sourceRatio) / Math.abs(sourceRatio)
+      : null;
+  const boundaryIntegrity =
+    Number.isFinite(Number(result?.boundaryIntegrity))
+      ? Math.max(0, Math.min(1, Number(result.boundaryIntegrity)))
+      : null;
+
+  const aspectOk =
+    aspectDrift != null &&
+    aspectDrift <= profile.vectorization.maxAspectDrift;
+  const boundaryOk =
+    boundaryIntegrity != null &&
+    boundaryIntegrity >= profile.vectorization.minBoundaryIntegrity;
+
+  return Object.freeze({
+    verified: aspectOk && boundaryOk,
+    aspectOk,
+    boundaryOk,
+    aspectDrift,
+    boundaryIntegrity,
+    thresholds: Object.freeze({
+      maxAspectDrift: profile.vectorization.maxAspectDrift,
+      minBoundaryIntegrity: profile.vectorization.minBoundaryIntegrity,
+    }),
+    reason:
+      aspectDrift == null
+        ? "aspect_ratio_unavailable"
+        : !aspectOk
+          ? "aspect_ratio_drift"
+          : boundaryIntegrity == null
+            ? "boundary_integrity_unavailable"
+            : !boundaryOk
+              ? "boundary_integrity_below_threshold"
+              : null,
+  });
+}

package/packages/agentsam-merch/test/merch.test.mjs

@@ -0,0 +1,332 @@
+import assert from "node:assert/strict";
+import { readFile } from "node:fs/promises";
+import test from "node:test";
+import {
+  COLLECTION_CANDIDATE_STATE,
+  COMPATIBILITY_STATUS,
+  approvalsComplete,
+  calculateEffectivePpi,
+  createCollectionCandidate,
+  createManufacturingProfileRegistry,
+  createProductConceptRegistry,
+  evaluateManufacturingCompatibility,
+  planAutomaticTransforms,
+  planMediaDerivatives,
+  resolveProductConceptTarget,
+  transitionCollectionCandidate,
+  validateManufacturingProfile,
+  verifyVectorizationResult,
+} from "../src/index.js";
+
+async function profile(name) {
+  return JSON.parse(await readFile(new URL(`../profiles/${name}`, import.meta.url), "utf8"));
+}
+
+test("profile data validates", async () => {
+  for (const name of [
+    "completeful/dtg-back-large.json",
+    "completeful/laser-engraving.json",
+    "generic/embroidery-digitization.json",
+  ]) {
+    const result = validateManufacturingProfile(await profile(name));
+    assert.equal(result.ok, true, `${name}: ${result.errors.join(", ")}`);
+  }
+});
+
+test("large transparent PNG is ready for the verified Completeful DTG profile", async () => {
+  const result = evaluateManufacturingCompatibility(
+    {
+      format: "png",
+      mediaKind: "raster",
+      widthPx: 4500,
+      heightPx: 5100,
+      bytes: 12000000,
+      colorSpace: "srgb",
+      hasAlpha: true
+    },
+    await profile("completeful/dtg-back-large.json"),
+    { printWidthIn: 14, printHeightIn: 16 },
+  );
+  assert.equal(result.status, COMPATIBILITY_STATUS.READY);
+  assert.equal(result.requirementsVerified, true);
+  assert.equal(result.productionReady, true);
+  assert.ok(result.effectivePpi >= 300);
+});
+
+test("low-resolution raster is not falsely called production ready", async () => {
+  const result = evaluateManufacturingCompatibility(
+    { format: "png", mediaKind: "raster", widthPx: 1500, heightPx: 1500, colorSpace: "srgb" },
+    await profile("completeful/dtg-back-large.json"),
+    { printWidthIn: 14, printHeightIn: 16 },
+  );
+  assert.equal(result.status, COMPATIBILITY_STATUS.NEEDS_VARIANT);
+  assert.ok(result.issues.some((issue) => issue.code === "insufficient_resolution"));
+});
+
+test("engraving rejects gradient/open-path artwork", async () => {
+  const result = evaluateManufacturingCompatibility(
+    {
+      format: "svg",
+      mediaKind: "vector",
+      colorMode: "full-color",
+      hasGradients: true,
+      hasOpenPaths: true,
+      hasLiveText: true
+    },
+    await profile("completeful/laser-engraving.json"),
+  );
+  assert.equal(result.status, COMPATIBILITY_STATUS.NEEDS_VARIANT);
+  assert.ok(result.actions.includes("simplify_gradients"));
+  assert.ok(result.actions.includes("close_paths"));
+});
+
+test("embroidery stops at prepared for digitization", async () => {
+  const result = evaluateManufacturingCompatibility(
+    {
+      format: "svg",
+      mediaKind: "vector",
+      colorMode: "spot",
+      hasGradients: false,
+      hasOpenPaths: false,
+      hasLiveText: false
+    },
+    await profile("generic/embroidery-digitization.json"),
+  );
+  assert.equal(result.status, COMPATIBILITY_STATUS.PREPARED_FOR_DIGITIZATION);
+  assert.equal(result.productionReady, false);
+});
+
+test("manufacturing and storefront derivatives remain separate", async () => {
+  const plan = planMediaDerivatives({
+    asset: { format: "png", mediaKind: "raster", widthPx: 4500, heightPx: 5100, colorSpace: "srgb" },
+    profile: await profile("completeful/dtg-back-large.json"),
+    target: { printWidthIn: 14, printHeightIn: 16 },
+  });
+  assert.equal(plan.source.immutableAuthority, true);
+  assert.equal(plan.manufacturing.format, "png");
+  assert.equal(plan.storefront.format, "webp");
+  assert.equal(plan.manufacturing.mustNotUseStorefrontDerivative, true);
+});
+
+test("profile registry selects using data selectors", async () => {
+  const registry = createManufacturingProfileRegistry([
+    await profile("completeful/dtg-back-large.json"),
+    await profile("completeful/laser-engraving.json"),
+  ]);
+  assert.equal(
+    registry.select({
+      manufacturer: "completeful",
+      process: "dtg",
+      locationName: "Back",
+      printWidthIn: 14,
+    })?.id,
+    "completeful.dtg.back-large",
+  );
+});
+
+test("collection lab uses explicit approvals and valid transitions", () => {
+  const concept = createCollectionCandidate({
+    id: "burn-it-gt-back-tee",
+    designId: "burn-it-gt",
+    collectionPath: ["Fuel & Free Time", "Performance", "Burn It GT"],
+    approvals: { artwork: true, wording: true, palette: true, visualIdentity: true },
+  });
+  assert.equal(approvalsComplete(concept), true);
+  const approved = transitionCollectionCandidate(
+    concept,
+    COLLECTION_CANDIDATE_STATE.APPROVED_ART,
+  );
+  assert.equal(approved.state, COLLECTION_CANDIDATE_STATE.APPROVED_ART);
+  assert.throws(() =>
+    transitionCollectionCandidate(approved, COLLECTION_CANDIDATE_STATE.PUBLISHED),
+  );
+});
+
+
+test("effective PPI follows actual physical placement geometry", () => {
+  const profile = {
+    id: "test.dtg",
+    manufacturer: "test",
+    process: "dtg",
+    format: "png",
+    allowRaster: true,
+    resolution: { readyPpi: 300, minimumPpi: 200 },
+    source: { verified: true },
+  };
+
+  const ready = evaluateManufacturingCompatibility(
+    { format: "png", widthPx: 3000, heightPx: 3600, colorSpace: "srgb" },
+    profile,
+    { placementWidthIn: 10, placementHeightIn: 12 },
+  );
+  assert.equal(ready.effectivePpi, 300);
+  assert.equal(ready.status, COMPATIBILITY_STATUS.READY);
+
+  const warning = evaluateManufacturingCompatibility(
+    { format: "png", widthPx: 2400, heightPx: 2880, colorSpace: "srgb" },
+    profile,
+    { placementWidthIn: 10, placementHeightIn: 12 },
+  );
+  assert.equal(warning.effectivePpi, 240);
+  assert.equal(warning.status, COMPATIBILITY_STATUS.READY_WITH_WARNING);
+  assert.equal(warning.productionReady, true);
+
+  const fail = evaluateManufacturingCompatibility(
+    { format: "png", widthPx: 1500, heightPx: 1800, colorSpace: "srgb" },
+    profile,
+    { placementWidthIn: 10, placementHeightIn: 12 },
+  );
+  assert.equal(fail.effectivePpi, 150);
+  assert.equal(fail.status, COMPATIBILITY_STATUS.NEEDS_VARIANT);
+});
+
+test("content bounds, not transparent canvas bounds, drive effective PPI", () => {
+  const profile = {
+    id: "test.dtg.trim",
+    manufacturer: "test",
+    process: "dtg",
+    format: "png",
+    allowRaster: true,
+    resolution: { readyPpi: 300, minimumPpi: 200 },
+    autoNormalize: { trimAlpha: true },
+  };
+  const ppi = calculateEffectivePpi(
+    {
+      format: "png",
+      widthPx: 5000,
+      heightPx: 5000,
+      contentWidthPx: 2400,
+      contentHeightPx: 3000,
+      transparentBorderDetected: true,
+      isAlphaTrimmed: false,
+    },
+    profile,
+    { placementWidthIn: 10, placementHeightIn: 10 },
+  );
+  assert.equal(ppi.basis, "content_bounds");
+  assert.equal(ppi.effectivePpi, 240);
+
+  const compatibility = evaluateManufacturingCompatibility(
+    {
+      format: "png",
+      widthPx: 5000,
+      heightPx: 5000,
+      contentWidthPx: 2400,
+      contentHeightPx: 3000,
+      transparentBorderDetected: true,
+      isAlphaTrimmed: false,
+    },
+    profile,
+    { placementWidthIn: 10, placementHeightIn: 10 },
+  );
+  assert.ok(compatibility.actions.includes("trim_alpha"));
+  assert.equal(compatibility.status, COMPATIBILITY_STATUS.READY_WITH_TRANSFORM);
+});
+
+test("engraving raster can be auto-vectorized but is never silently called ready", async () => {
+  const engraving = await profile("completeful/laser-engraving.json");
+  const compatibility = evaluateManufacturingCompatibility(
+    {
+      format: "png",
+      mediaKind: "raster",
+      widthPx: 3000,
+      heightPx: 3000,
+      colorMode: "full-color",
+    },
+    engraving,
+  );
+  assert.equal(compatibility.status, COMPATIBILITY_STATUS.READY_WITH_TRANSFORM);
+  assert.ok(compatibility.actions.includes("vectorize_monochrome"));
+
+  const plan = planAutomaticTransforms({
+    asset: {
+      format: "png",
+      mediaKind: "raster",
+      widthPx: 3000,
+      heightPx: 3000,
+      colorMode: "full-color",
+    },
+    profile: engraving,
+    capabilities: {
+      vector_tracer: true,
+      raster_normalizer: true,
+    },
+  });
+  assert.ok(plan.operations.some((operation) => operation.id === "vectorize_monochrome"));
+  assert.ok(plan.operations.every((operation) => operation.id !== "vectorize_monochrome" || operation.executable));
+});
+
+test("vectorization result must preserve aspect ratio and boundary integrity", async () => {
+  const engraving = await profile("completeful/laser-engraving.json");
+  const good = verifyVectorizationResult({
+    source: { widthPx: 1000, heightPx: 500 },
+    result: { widthPx: 1000, heightPx: 500, boundaryIntegrity: 0.995 },
+    profile: engraving,
+  });
+  assert.equal(good.verified, true);
+
+  const bad = verifyVectorizationResult({
+    source: { widthPx: 1000, heightPx: 500 },
+    result: { widthPx: 900, heightPx: 500, boundaryIntegrity: 0.91 },
+    profile: engraving,
+  });
+  assert.equal(bad.verified, false);
+  assert.ok(["aspect_ratio_drift", "boundary_integrity_below_threshold"].includes(bad.reason));
+});
+
+test("product concepts select providers without baking provider logic into the engine", () => {
+  const profiles = createManufacturingProfileRegistry([
+    {
+      id: "provider-a.dtg.standard",
+      manufacturer: "provider-a",
+      process: "dtg",
+      format: "png",
+      allowRaster: true,
+    },
+    {
+      id: "provider-b.dtg.standard",
+      manufacturer: "provider-b",
+      process: "dtg",
+      format: "png",
+      allowRaster: true,
+    },
+  ]);
+  const concepts = createProductConceptRegistry([
+    {
+      id: "heavyweight-graphic-tee",
+      label: "Heavyweight Graphic Tee",
+      targets: [
+        { provider: "provider-a", profileId: "provider-a.dtg.standard", priority: 0 },
+        { provider: "provider-b", profileId: "provider-b.dtg.standard", priority: 10 },
+      ],
+    },
+  ]);
+  const resolved = resolveProductConceptTarget(
+    concepts.get("heavyweight-graphic-tee"),
+    {
+      profileRegistry: profiles,
+      availableProviders: ["provider-b"],
+    },
+  );
+  assert.equal(resolved.selected.provider, "provider-b");
+  assert.equal(resolved.selected.profileId, "provider-b.dtg.standard");
+});
+
+test("missing provider warning threshold fails closed instead of inventing one", () => {
+  const profile = {
+    id: "test.strict",
+    manufacturer: "test",
+    process: "dtg",
+    format: "png",
+    allowRaster: true,
+    ppi: 300,
+    source: { verified: true },
+  };
+  const result = evaluateManufacturingCompatibility(
+    { format: "png", widthPx: 2500, heightPx: 2500 },
+    profile,
+    { placementWidthIn: 10, placementHeightIn: 10 },
+  );
+  assert.equal(result.status, COMPATIBILITY_STATUS.NEEDS_VARIANT);
+  assert.equal(result.resolution.minimumPpi, 300);
+});

package/packages/agentsam-merch/test/node-transforms.test.mjs

@@ -0,0 +1,149 @@
+import assert from "node:assert/strict";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import test from "node:test";
+
+import {
+  detectNodeTransformCapabilities,
+  inspectRaster,
+  normalizeRaster,
+  traceRasterToSvg,
+} from "../src/node/index.js";
+import { verifyVectorizationResult } from "../src/index.js";
+
+const execFileAsync = promisify(execFile);
+
+async function sharpModule() {
+  try {
+    const mod = await import("sharp");
+    return mod.default || mod;
+  } catch {
+    return null;
+  }
+}
+
+async function makeTransparentFixture(sharp) {
+  const base = await sharp({
+    create: {
+      width: 400,
+      height: 300,
+      channels: 4,
+      background: { r: 0, g: 0, b: 0, alpha: 0 },
+    },
+  })
+    .composite([
+      {
+        input: {
+          create: {
+            width: 240,
+            height: 180,
+            channels: 4,
+            background: { r: 20, g: 20, b: 20, alpha: 1 },
+          },
+        },
+        left: 80,
+        top: 60,
+      },
+    ])
+    .png()
+    .toBuffer();
+  return base;
+}
+
+test("node raster inspector measures visible alpha bounds", async (t) => {
+  const sharp = await sharpModule();
+  if (!sharp) return t.skip("sharp unavailable");
+  const source = await makeTransparentFixture(sharp);
+  const descriptor = await inspectRaster(source, { sharp });
+  assert.equal(descriptor.widthPx, 400);
+  assert.equal(descriptor.heightPx, 300);
+  assert.equal(descriptor.contentWidthPx, 240);
+  assert.equal(descriptor.contentHeightPx, 180);
+  assert.equal(descriptor.transparentBorderDetected, true);
+});
+
+test("node raster normalizer trims alpha without upscaling", async (t) => {
+  const sharp = await sharpModule();
+  if (!sharp) return t.skip("sharp unavailable");
+  const source = await makeTransparentFixture(sharp);
+  const result = await normalizeRaster(source, {
+    sharp,
+    format: "png",
+    operations: [
+      { id: "trim_alpha", params: {} },
+      { id: "normalize_color_space", params: { colorSpace: "srgb" } },
+    ],
+  });
+  assert.equal(result.descriptor.widthPx, 240);
+  assert.equal(result.descriptor.heightPx, 180);
+  assert.equal(result.descriptor.colorSpace, "srgb");
+});
+
+test("installed potrace produces a verifiable monochrome SVG derivative", async (t) => {
+  const sharp = await sharpModule();
+  if (!sharp) return t.skip("sharp unavailable");
+  try {
+    await execFileAsync("potrace", ["--version"]);
+  } catch {
+    return t.skip("potrace unavailable");
+  }
+
+  const source = await sharp({
+    create: {
+      width: 300,
+      height: 180,
+      channels: 3,
+      background: "#ffffff",
+    },
+  })
+    .composite([
+      {
+        input: {
+          create: {
+            width: 180,
+            height: 90,
+            channels: 3,
+            background: "#000000",
+          },
+        },
+        left: 60,
+        top: 45,
+      },
+    ])
+    .png()
+    .toBuffer();
+
+  const traced = await traceRasterToSvg(source, { tracer: "potrace", sharp });
+  assert.equal(traced.tracer, "potrace");
+  assert.match(traced.svg, /<svg\b/);
+  assert.ok(traced.metrics.boundaryIntegrity > 0.9);
+
+  const verification = verifyVectorizationResult({
+    source: { widthPx: 300, heightPx: 180 },
+    result: {
+      widthPx: traced.metrics.width,
+      heightPx: traced.metrics.height,
+      boundaryIntegrity: traced.metrics.boundaryIntegrity,
+    },
+    profile: {
+      id: "local.engraving",
+      manufacturer: "local",
+      process: "engraving",
+      format: "svg",
+      allowVector: true,
+      vectorization: {
+        enabled: true,
+        maxAspectDrift: 0.02,
+        minBoundaryIntegrity: 0.9,
+      },
+    },
+  });
+  assert.equal(verification.verified, true);
+});
+
+test("capability probe reports machine transforms without inventing unavailable tools", async () => {
+  const capabilities = await detectNodeTransformCapabilities();
+  assert.equal(typeof capabilities.raster_normalizer, "boolean");
+  assert.equal(typeof capabilities.vector_tracer, "boolean");
+  assert.equal(typeof capabilities.tools.svgo, "boolean");
+});