@hraness/slopcamera 3.2.8 → 3.3.2

package/src/mcp/types.ts

@@ -1,4 +1,5 @@
 import type { SlopcameraGenerateDependencies } from "../generate.js"
+import type { HostResourceCoordinator } from "../host-resources.js"
 
 export type JsonRpcId = string | number
 export type JsonRpcResponseId = JsonRpcId | null
@@ -37,6 +38,19 @@ export interface McpToolDefinition {
     | "render_diagram"
     | "search_slopcamera"
     | "execute_slopcamera"
+    | "check_scene"
+    | "inspect_scene"
+    | "audit_scene"
+    | "diff_scenes"
+    | "evaluate_scene"
+    | "check_scene_direction"
+    | "plan_scene_direction"
+    | "plan_scene_gallery"
+    | "check_scene_effects"
+    | "plan_scene_effects"
+    | "check_scene_behavior"
+    | "audit_scene_behavior"
+    | "audit_scene_temporal"
   readonly title: string
   readonly description: string
   readonly inputSchema: Readonly<Record<string, unknown>>
@@ -68,4 +82,9 @@ export interface McpServerOptions {
   readonly serverVersion?: string
   /** Injectable Gateway runtime, environment, and fixed-origin fetch seams. */
   readonly generateDependencies?: SlopcameraGenerateDependencies
+  /**
+   * Injectable host-resource admission coordinator. Defaults to the
+   * machine-global coordinator; tests inject a process-local stand-in.
+   */
+  readonly hostResourceCoordinator?: HostResourceCoordinator
 }

package/src/operations.ts

@@ -14,6 +14,19 @@ import {
   type SlopcameraGenerateDependencies,
   type SlopcameraImageModel,
 } from "./generate.js"
+import {
+  generateSlopcameraIcon,
+  slopcameraIconMaximumRounds,
+  slopcameraIconSubjectMaximumBytes,
+  type SlopcameraIconReceipt,
+} from "./icon.js"
+import {
+  generateSlopcameraImageGallery,
+  slopcameraGalleryAxes,
+  slopcameraGalleryKinds,
+  slopcameraGalleryLimits,
+  type SlopcameraGalleryReceipt,
+} from "./image-gallery.js"
 import {
   vectorizeImage,
   type VectorizeReceipt,
@@ -30,6 +43,8 @@ export const slopcameraOperationCodes = [
   "slopcamera.diagram.render",
   "slopcamera.image.vectorize",
   "slopcamera.image.generate",
+  "slopcamera.image.icon",
+  "slopcamera.image.gallery",
 ] as const
 
 export type SlopcameraOperationCode = (typeof slopcameraOperationCodes)[number]
@@ -209,6 +224,157 @@ export const slopcameraOperationRegistry: readonly SlopcameraOperationDescriptor
         retry: "never",
       },
     },
+    {
+      code: "slopcamera.image.icon",
+      title: "Generate line-art icon",
+      description:
+        "Generate one isometric line-art SVG icon: a style-locked Vercel AI Gateway raster normalized to canonical ink-on-transparent pixels, traced locally, and optionally critiqued by a vision model across bounded rounds.",
+      execution: "gateway",
+      authentication: "environment",
+      destructive: true,
+      idempotent: false,
+      inputSchema: {
+        type: "object",
+        additionalProperties: false,
+        required: ["subject", "outputPath"],
+        properties: {
+          subject: {
+            type: "string",
+            minLength: 1,
+            maxLength: slopcameraIconSubjectMaximumBytes,
+          },
+          outputPath: pathSchema,
+          model: modelSchema,
+          critiqueModel: modelSchema,
+          ink: {
+            type: "string",
+            pattern: "^#[a-fA-F0-9]{3}(?:[a-fA-F0-9]{3})?$",
+          },
+          purpose: { type: "string", enum: ["mark", "illustration"] },
+          rounds: {
+            type: "integer",
+            minimum: 1,
+            maximum: slopcameraIconMaximumRounds,
+          },
+          keepRaster: { type: "boolean" },
+        },
+      },
+      resources: [
+        { resource: "cpu", amount: 1 },
+        { resource: "local-io", amount: 1 },
+        { resource: "network", amount: 1 },
+        { resource: "paid-call", amount: 1 },
+      ],
+      transport: {
+        method: "POST",
+        authority: "https://ai-gateway.vercel.sh/v4/ai",
+        authorization: "bearer",
+        retry: "never",
+      },
+    },
+    {
+      code: "slopcamera.image.gallery",
+      title: "Generate image gallery",
+      description:
+        "Generate several bounded Vercel AI Gateway image candidates in parallel and compose a labelled contact sheet with per-candidate provenance for explicit review and selection.",
+      execution: "gateway",
+      authentication: "environment",
+      destructive: true,
+      idempotent: false,
+      inputSchema: {
+        type: "object",
+        additionalProperties: false,
+        required: ["subject", "outputDir"],
+        properties: {
+          subject: {
+            type: "string",
+            minLength: 1,
+            maxLength: slopcameraGalleryLimits.subjectBytes,
+          },
+          outputDir: pathSchema,
+          kind: { type: "string", enum: [...slopcameraGalleryKinds] },
+          model: modelSchema,
+          count: {
+            type: "integer",
+            minimum: 1,
+            maximum: slopcameraGalleryLimits.candidates,
+          },
+          vary: {
+            type: "array",
+            maxItems: slopcameraGalleryAxes.length,
+            items: {
+              anyOf: [
+                { type: "string", enum: [...slopcameraGalleryAxes] },
+                {
+                  type: "object",
+                  additionalProperties: false,
+                  required: ["axis"],
+                  properties: {
+                    axis: { type: "string", enum: [...slopcameraGalleryAxes] },
+                    values: {
+                      type: "array",
+                      minItems: 1,
+                      maxItems: slopcameraGalleryLimits.candidates,
+                      items: {
+                        type: "string",
+                        minLength: 1,
+                        maxLength: slopcameraGalleryLimits.variantBytes,
+                      },
+                    },
+                  },
+                },
+              ],
+            },
+          },
+          candidates: {
+            type: "array",
+            minItems: 1,
+            maxItems: slopcameraGalleryLimits.candidates,
+            items: {
+              type: "object",
+              additionalProperties: false,
+              required: ["id"],
+              properties: {
+                id: {
+                  type: "string",
+                  minLength: 1,
+                  maxLength: slopcameraGalleryLimits.idLength,
+                },
+                prompt: {
+                  type: "string",
+                  minLength: 1,
+                  maxLength: slopcameraGalleryLimits.candidatePromptBytes,
+                },
+                variant: {
+                  type: "string",
+                  minLength: 1,
+                  maxLength: slopcameraGalleryLimits.variantBytes,
+                },
+              },
+            },
+          },
+          cellEdge: {
+            type: "integer",
+            minimum: slopcameraGalleryLimits.cellEdgeMin,
+            maximum: slopcameraGalleryLimits.cellEdgeMax,
+          },
+          tiled: { type: "boolean" },
+          timeoutMs: { type: "integer", minimum: 1_000, maximum: 30 * 60_000 },
+        },
+      },
+      resources: [
+        { resource: "cpu", amount: 1 },
+        { resource: "local-io", amount: 1 },
+        { resource: "network", amount: 1 },
+        { resource: "paid-call", amount: 1 },
+      ],
+      transport: {
+        method: "POST",
+        authority: "https://ai-gateway.vercel.sh/v4/ai",
+        authorization: "bearer",
+        retry: "never",
+      },
+    },
   ] satisfies readonly SlopcameraOperationDescriptor[])
 
 export interface CheckSlopcameraOperationInput {
@@ -234,11 +400,37 @@ export interface GenerateSlopcameraOperationInput {
   readonly outputPath: string
 }
 
+export interface IconSlopcameraOperationInput {
+  readonly subject: string
+  readonly outputPath: string
+  readonly model?: SlopcameraImageModel
+  readonly critiqueModel?: string
+  readonly ink?: string
+  readonly purpose?: "illustration" | "mark"
+  readonly rounds?: number
+  readonly keepRaster?: boolean
+}
+
+export interface GallerySlopcameraOperationInput {
+  readonly subject: string
+  readonly outputDir: string
+  readonly kind?: string
+  readonly model?: SlopcameraImageModel
+  readonly count?: number
+  readonly vary?: readonly unknown[]
+  readonly candidates?: readonly unknown[]
+  readonly cellEdge?: number
+  readonly tiled?: boolean
+  readonly timeoutMs?: number
+}
+
 export interface SlopcameraOperationInputMap {
   readonly "slopcamera.diagram.check": CheckSlopcameraOperationInput
   readonly "slopcamera.diagram.render": RenderSlopcameraOperationInput
   readonly "slopcamera.image.vectorize": VectorizeSlopcameraOperationInput
   readonly "slopcamera.image.generate": GenerateSlopcameraOperationInput
+  readonly "slopcamera.image.icon": IconSlopcameraOperationInput
+  readonly "slopcamera.image.gallery": GallerySlopcameraOperationInput
 }
 
 export interface SlopcameraOperationResultMap {
@@ -256,6 +448,8 @@ export interface SlopcameraOperationResultMap {
     readonly receipt: VectorizeReceipt
   }
   readonly "slopcamera.image.generate": GeneratedSlopcameraImageFile
+  readonly "slopcamera.image.icon": SlopcameraIconReceipt
+  readonly "slopcamera.image.gallery": SlopcameraGalleryReceipt
 }
 
 function operationFailure(message: string): never {
@@ -401,6 +595,190 @@ function parseGenerate(value: unknown): GenerateSlopcameraOperationInput {
   }
 }
 
+function parseIcon(value: unknown): IconSlopcameraOperationInput {
+  const input = record(value, [
+    "subject",
+    "outputPath",
+    "model",
+    "critiqueModel",
+    "ink",
+    "rounds",
+    "keepRaster",
+  ])
+  if (
+    typeof input.subject !== "string" ||
+    input.subject.trim().length < 1 ||
+    /[\u0000-\u001f\u007f]/u.test(input.subject) ||
+    Buffer.byteLength(input.subject, "utf8") > slopcameraIconSubjectMaximumBytes
+  ) {
+    operationFailure(
+      `subject must be non-empty and no more than ${slopcameraIconSubjectMaximumBytes} UTF-8 bytes.`,
+    )
+  }
+  const outputPath = pathValue(input.outputPath, "outputPath")
+  if (!outputPath.toLowerCase().endsWith(".svg")) {
+    operationFailure("outputPath must end in .svg.")
+  }
+  for (const name of ["model", "critiqueModel"] as const) {
+    const model = input[name]
+    if (
+      model !== undefined &&
+      (typeof model !== "string" ||
+        model.length > 256 ||
+        !/^[a-z0-9][a-z0-9._-]*\/[a-z0-9][a-z0-9._:-]*$/iu.test(model))
+    ) {
+      operationFailure(`${name} must be a bounded Vercel AI Gateway provider/model id.`)
+    }
+  }
+  if (
+    input.ink !== undefined &&
+    (typeof input.ink !== "string" ||
+      !/^#[a-f0-9]{3}(?:[a-f0-9]{3})?$/iu.test(input.ink))
+  ) {
+    operationFailure("ink must be a #rgb or #rrggbb color.")
+  }
+  const rounds = input.rounds
+  if (
+    rounds !== undefined &&
+    (!Number.isInteger(rounds) ||
+      (rounds as number) < 1 ||
+      (rounds as number) > slopcameraIconMaximumRounds)
+  ) {
+    operationFailure(
+      `rounds must be an integer from 1 through ${slopcameraIconMaximumRounds}.`,
+    )
+  }
+  if (
+    input.keepRaster !== undefined &&
+    typeof input.keepRaster !== "boolean"
+  ) {
+    operationFailure("keepRaster must be a boolean.")
+  }
+  return {
+    subject: input.subject,
+    outputPath,
+    ...(input.model === undefined
+      ? {}
+      : { model: input.model as SlopcameraImageModel }),
+    ...(input.critiqueModel === undefined
+      ? {}
+      : { critiqueModel: input.critiqueModel as string }),
+    ...(input.ink === undefined ? {} : { ink: input.ink as string }),
+    ...(rounds === undefined ? {} : { rounds: rounds as number }),
+    ...(input.keepRaster === undefined
+      ? {}
+      : { keepRaster: input.keepRaster as boolean }),
+  }
+}
+
+function parseGallery(value: unknown): GallerySlopcameraOperationInput {
+  const input = record(value, [
+    "subject",
+    "outputDir",
+    "kind",
+    "model",
+    "count",
+    "vary",
+    "candidates",
+    "cellEdge",
+    "tiled",
+    "timeoutMs",
+  ])
+  if (
+    typeof input.subject !== "string" ||
+    input.subject.trim().length < 1 ||
+    /[\u0000-\u001f\u007f]/u.test(input.subject) ||
+    Buffer.byteLength(input.subject, "utf8") > slopcameraGalleryLimits.subjectBytes
+  ) {
+    operationFailure(
+      `subject must be non-empty and no more than ${slopcameraGalleryLimits.subjectBytes} UTF-8 bytes.`,
+    )
+  }
+  if (
+    input.kind !== undefined &&
+    (typeof input.kind !== "string" || !slopcameraGalleryKinds.includes(input.kind as never))
+  ) {
+    operationFailure(`kind must be one of: ${slopcameraGalleryKinds.join(", ")}.`)
+  }
+  if (
+    input.model !== undefined &&
+    (typeof input.model !== "string" ||
+      input.model.length > 256 ||
+      !/^[a-z0-9][a-z0-9._-]*\/[a-z0-9][a-z0-9._:-]*$/iu.test(input.model))
+  ) {
+    operationFailure("model must be a bounded Vercel AI Gateway provider/model id.")
+  }
+  if (
+    input.count !== undefined &&
+    (!Number.isInteger(input.count) ||
+      (input.count as number) < 1 ||
+      (input.count as number) > slopcameraGalleryLimits.candidates)
+  ) {
+    operationFailure(`count must be an integer from 1 through ${slopcameraGalleryLimits.candidates}.`)
+  }
+  if (
+    input.vary !== undefined &&
+    (!Array.isArray(input.vary) || input.vary.length < 1 || input.vary.length > slopcameraGalleryAxes.length)
+  ) {
+    operationFailure(`vary must be a list of at most ${slopcameraGalleryAxes.length} axes.`)
+  }
+  if (
+    input.candidates !== undefined &&
+    (!Array.isArray(input.candidates) ||
+      input.candidates.length < 1 ||
+      input.candidates.length > slopcameraGalleryLimits.candidates)
+  ) {
+    operationFailure(`candidates must contain 1 through ${slopcameraGalleryLimits.candidates} entries.`)
+  }
+  if (
+    input.vary !== undefined &&
+    input.candidates !== undefined
+  ) {
+    operationFailure("vary and candidates are mutually exclusive.")
+  }
+  if (
+    input.count !== undefined &&
+    input.candidates !== undefined
+  ) {
+    operationFailure("count and candidates are mutually exclusive.")
+  }
+  const cellEdge = input.cellEdge
+  if (
+    cellEdge !== undefined &&
+    (!Number.isInteger(cellEdge) ||
+      (cellEdge as number) < slopcameraGalleryLimits.cellEdgeMin ||
+      (cellEdge as number) > slopcameraGalleryLimits.cellEdgeMax)
+  ) {
+    operationFailure(
+      `cellEdge must be an integer from ${slopcameraGalleryLimits.cellEdgeMin} through ${slopcameraGalleryLimits.cellEdgeMax}.`,
+    )
+  }
+  const timeoutMs = input.timeoutMs
+  if (
+    timeoutMs !== undefined &&
+    (!Number.isInteger(timeoutMs) ||
+      (timeoutMs as number) < 1_000 ||
+      (timeoutMs as number) > 30 * 60_000)
+  ) {
+    operationFailure("timeoutMs must be an integer from 1000 through 1800000.")
+  }
+  if (input.tiled !== undefined && typeof input.tiled !== "boolean") {
+    operationFailure("tiled must be a boolean when set.")
+  }
+  return {
+    subject: input.subject as string,
+    outputDir: pathValue(input.outputDir, "outputDir"),
+    ...(input.kind === undefined ? {} : { kind: input.kind as string }),
+    ...(input.model === undefined ? {} : { model: input.model as SlopcameraImageModel }),
+    ...(input.count === undefined ? {} : { count: input.count as number }),
+    ...(input.vary === undefined ? {} : { vary: input.vary as readonly unknown[] }),
+    ...(input.candidates === undefined ? {} : { candidates: input.candidates as readonly unknown[] }),
+    ...(cellEdge === undefined ? {} : { cellEdge: cellEdge as number }),
+    ...(input.tiled === undefined ? {} : { tiled: input.tiled as boolean }),
+    ...(timeoutMs === undefined ? {} : { timeoutMs: timeoutMs as number }),
+  }
+}
+
 export function parseSlopcameraOperationInput<C extends SlopcameraOperationCode>(
   code: C,
   input: unknown,
@@ -414,6 +792,10 @@ export function parseSlopcameraOperationInput<C extends SlopcameraOperationCode>
       return parseVectorize(input) as SlopcameraOperationInputMap[C]
     case "slopcamera.image.generate":
       return parseGenerate(input) as SlopcameraOperationInputMap[C]
+    case "slopcamera.image.icon":
+      return parseIcon(input) as SlopcameraOperationInputMap[C]
+    case "slopcamera.image.gallery":
+      return parseGallery(input) as SlopcameraOperationInputMap[C]
     default:
       throw new SlopcameraOperationError(
         "INVALID_OPERATION",
@@ -698,6 +1080,36 @@ async function executeSlopcameraOperationUncoordinated<
         dependencies,
       )) as SlopcameraOperationResultMap[C]
     }
+    case "slopcamera.image.icon": {
+      const options = input as IconSlopcameraOperationInput
+      return (await generateSlopcameraIcon(
+        {
+          ...options,
+          ...(dependencies.signal === undefined
+            ? {}
+            : { signal: dependencies.signal }),
+          ...(dependencies.inheritedFileDescriptors === undefined
+            ? {}
+            : {
+                inheritedFileDescriptors:
+                  dependencies.inheritedFileDescriptors,
+              }),
+        },
+        dependencies,
+      )) as SlopcameraOperationResultMap[C]
+    }
+    case "slopcamera.image.gallery": {
+      const options = input as GallerySlopcameraOperationInput
+      return (await generateSlopcameraImageGallery(
+        {
+          ...options,
+          ...(dependencies.signal === undefined
+            ? {}
+            : { signal: dependencies.signal }),
+        },
+        dependencies,
+      )) as SlopcameraOperationResultMap[C]
+    }
     default:
       throw new SlopcameraOperationError(
         "INVALID_OPERATION",

package/src/portable-capability-manifest.ts

@@ -0,0 +1,67 @@
+import {
+  compileSlopcameraCapabilityManifest,
+  defineSlopcameraCapabilityModule,
+  type SlopcameraCapabilityManifest,
+  type SlopcameraCapabilityOperation,
+} from "./capability-manifest.js"
+import {
+  PORTABLE_SLOPCAMERA_OPERATION_CONTRACTS,
+  PORTABLE_SLOPCAMERA_OPERATION_KINDS,
+  type PortableSlopcameraOperationKind,
+} from "./code/public-operations.js"
+
+export const SLOPCAMERA_PORTABLE_CAPABILITY_VERSION = "slopcamera-portable-v1" as const
+
+const portableModule = defineSlopcameraCapabilityModule({
+  commands: [],
+  description: "The fixed portable diagram and image operation projection for Bun SDK consumers.",
+  moduleId: "slopcamera.capability.portable-diagram-image",
+  operationKeys: PORTABLE_SLOPCAMERA_OPERATION_KINDS.map(kind => `${kind}@2`),
+  profiles: [{
+    id: "portable-bun-v1",
+    kind: "authoring",
+    qualification: { evidence: ["src/code/public-operations.ts"], level: "unit", status: "qualified" },
+    requirements: [{ description: "Bun 1.3.14 or newer.", id: "bun", optional: false }],
+  }],
+  stability: "stable",
+  title: "Portable diagrams and images",
+  toolNames: [],
+  trust: "portable",
+  version: 1,
+  workflowKeys: [],
+})
+
+function operationProjection(kind: PortableSlopcameraOperationKind): SlopcameraCapabilityOperation {
+  const operation = PORTABLE_SLOPCAMERA_OPERATION_CONTRACTS[kind]
+  return {
+    cache: operation.policy.cache,
+    cancellable: operation.policy.cancellable,
+    effect: operation.policy.effect,
+    inputSchemaId: operation.inputSchemaId,
+    key: `${operation.kind}@${operation.version}`,
+    kind: operation.kind,
+    lifecycle: operation.lifecycle,
+    maxDurationMs: operation.policy.maxDurationMs,
+    maxFanOut: operation.policy.maxFanOut,
+    maxInputBytes: operation.policy.maxInputBytes,
+    maxOutputBytes: operation.policy.maxOutputBytes,
+    outputSchemaId: operation.outputSchemaId,
+    preparation: [...operation.policy.preparation],
+    resources: operation.policy.resources.map(claim => ({ ...claim })),
+    resume: operation.policy.resume,
+    version: operation.version,
+  }
+}
+
+export function createPortableSlopcameraCapabilityManifest(): SlopcameraCapabilityManifest {
+  return compileSlopcameraCapabilityManifest({
+    host: "portable",
+    modules: [portableModule],
+    operations: PORTABLE_SLOPCAMERA_OPERATION_KINDS.map(operationProjection),
+    tools: [],
+    toolVersion: SLOPCAMERA_PORTABLE_CAPABILITY_VERSION,
+    workflows: [],
+  })
+}
+
+export const slopcameraPortableCapabilityManifest = createPortableSlopcameraCapabilityManifest()