@hraness/slopcamera 3.3.6 → 3.5.0

package/examples/style-portfolio/market-street/source.json

@@ -0,0 +1 @@
+{"engine":"blender","entrypoint":{"kind":"python","path":"scene.py"},"files":["mesh.py","scene.py","street_data.py"]}

package/examples/style-portfolio/market-street/street_data.py

@@ -0,0 +1,72 @@
+"""Evidence for the historical interpretation, separate from art direction.
+
+The scene is a compressed invented block inspired by the 1906 film. Dimensions,
+shop occupants, figure performances, and most facades are authored estimates.
+No building footprint is claimed to have been digitized from a Sanborn plate.
+"""
+
+SOURCES = [
+    {
+        'id': 'loc-film',
+        'url': 'https://www.loc.gov/item/00694408/',
+        'title': 'A trip down Market Street before the fire',
+        'institution': 'Library of Congress',
+        'supports': ['1906 setting', 'cable-car viewpoint toward Ferry Building',
+                     'black-and-white 35 mm source', 'mixed street traffic',
+                     'damp roadway visible in the film'],
+    },
+    {
+        'id': 'sfmta-conversion',
+        'url': 'https://www.sfmta.com/blog/how-1906-earthquake-transformed-our-public-transit-system',
+        'title': 'How the 1906 Earthquake Transformed Our Public Transit System',
+        'institution': 'San Francisco Municipal Transportation Agency',
+        'supports': ['electric conversion of Market Street followed the earthquake'],
+    },
+    {
+        'id': 'sfplanning-lamps',
+        'url': 'https://commissions.sfplanning.org/hpcpackets/2014.794A.pdf',
+        'title': 'Path of Gold Light Standards landmark case report',
+        'institution': 'San Francisco Planning Department',
+        'supports': ['Path of Gold bases date to 1908, globe tops to 1916'],
+    },
+]
+
+INTERPRETATION = {
+    'depictedPeriod': 'San Francisco, before the April 1906 earthquake',
+    'kind': 'procedural historical interpretation',
+    'historicalReconstruction': False,
+    'authoredEstimates': [
+        'All metric geometry, street compression, camera lens and height',
+        'Facades, shop names, costumes, individual vehicles and performances',
+        'Monochrome material response, weather, lighting and capture cadence',
+    ],
+    'excludedAnachronisms': ['Path of Gold globes', 'Market Street traction catenary'],
+}
+
+# +Y runs inland. The camera travels toward -Y. The shot faces the Ferry,
+# where screen-left is +X and screen-right is -X. Parcel coordinates are
+# composition coordinates, not surveyed geographic coordinates.
+ROAD_WIDTH = 26.0
+SIDEWALK_WIDTH = 5.3
+FERRY_Y = -12.0
+CAPTURE_FPS = 16
+DURATION_SECONDS = 6.0
+
+# Art-directed frontage parcels with separate setbacks at side-street cuts.
+# Values are (center Y, frontage, height, bays, material, roof treatment).
+PARCELS = {
+    -1: [(12, 22, 18, 6, 'stone', 'flat'),
+         (40, 23, 25, 6, 'brick', 'pediment'),
+         (70, 25, 20, 7, 'plaster', 'flat'),
+         (105, 30, 31, 8, 'brick_light', 'mansard'),
+         (146, 35, 24, 9, 'stone', 'pediment'),
+         (187, 31, 36, 8, 'brick', 'flat'),
+         (224, 30, 23, 8, 'plaster', 'flat')],
+    1: [(14, 24, 21, 7, 'brick_light', 'flat'),
+        (46, 25, 18, 7, 'stone', 'flat'),
+        (77, 27, 30, 8, 'brick', 'pediment'),
+        (111, 24, 22, 6, 'stone', 'flat'),
+        (148, 35, 33, 9, 'brick_light', 'mansard'),
+        (190, 34, 25, 9, 'plaster', 'pediment'),
+        (230, 33, 31, 9, 'brick', 'flat')],
+}

package/examples/style-portfolio/render-film-plate.ts

@@ -0,0 +1,128 @@
+/** Retain one local photographic plate and render a bounded single-image transfer study. */
+import { createHash } from "node:crypto";
+import { mkdir, open, realpath, writeFile } from "node:fs/promises";
+import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { fileURLToPath } from "node:url";
+import sharp from "sharp";
+import { z } from "zod";
+import { HtmlSceneInputSchema } from "../../apps/desktop/html-overlay/scene";
+
+const root = resolve(dirname(fileURLToPath(import.meta.url)), "../..");
+const maxBytes = 32 * 1024 * 1024;
+const maxPixels = 33_000_000;
+const args = process.argv.slice(2);
+const options = new Map<string, string>();
+let dryRun = false;
+for (let index = 0; index < args.length; index++) {
+  const arg = args[index]!;
+  if (arg === "--dry-run" && !dryRun) dryRun = true;
+  else if (["--image", "--run", "--width", "--height"].includes(arg) && args[index + 1] !== undefined) {
+    if (options.has(arg)) throw new Error(`Duplicate option ${arg}.`);
+    options.set(arg, args[++index]!);
+  } else throw new Error(`Unknown, duplicate, or incomplete option ${arg}.`);
+}
+const imageArg = options.get("--image");
+const run = options.get("--run");
+if (!imageArg || !run) throw new Error("Usage: bun examples/style-portfolio/render-film-plate.ts --image <local.png|local.jpg> --run <new-id> [--width <maximum>] [--height <maximum>] [--dry-run]");
+if (imageArg.length > 4096 || /[\0\r\n]/u.test(imageArg) || /^[a-z][a-z0-9+.-]*:\/\//iu.test(imageArg)) throw new Error("--image must be an explicit bounded local path, not a URL.");
+if (!/^[a-z0-9][a-z0-9-]{0,63}$/u.test(run)) throw new Error("--run must be a new short lowercase filename token.");
+function bound(name: string, fallback: number) {
+  const value = options.get(name);
+  if (value === undefined) return fallback;
+  if (!/^[0-9]{1,4}$/u.test(value)) throw new Error(`${name} must be an integer in [16,8192].`);
+  const parsed = Number(value);
+  if (parsed < 16 || parsed > 8192) throw new Error(`${name} must be an integer in [16,8192].`);
+  return parsed;
+}
+const hasSize = options.has("--width") || options.has("--height");
+const maxWidth = bound("--width", hasSize ? 8192 : 1440);
+const maxHeight = bound("--height", hasSize ? 8192 : 1080);
+const input = await realpath(resolve(root, imageArg));
+// Read from one handle with a fixed byte ceiling, then bind the retained copy.
+const handle = await open(input, "r");
+let bytes: Buffer;
+try {
+  const before = await handle.stat();
+  if (!before.isFile() || !Number.isSafeInteger(before.size) || before.size < 1 || before.size > maxBytes) throw new Error("Use a regular PNG/JPEG file no larger than 32 MiB.");
+  bytes = Buffer.alloc(before.size);
+  let position = 0;
+  while (position < bytes.length) {
+    const result = await handle.read(bytes, position, bytes.length - position, position);
+    if (result.bytesRead === 0) throw new Error("The plate changed while it was read.");
+    position += result.bytesRead;
+  }
+  const extra = await handle.read(Buffer.alloc(1), 0, 1, position);
+  const after = await handle.stat();
+  if (extra.bytesRead !== 0 || after.size !== before.size || after.mtimeMs !== before.mtimeMs || after.ino !== before.ino || after.dev !== before.dev) throw new Error("The plate changed while it was read.");
+} finally { await handle.close(); }
+const metadata = await sharp(bytes, { limitInputPixels: maxPixels, failOn: "error", animated: true }).metadata();
+if (!["png", "jpeg"].includes(metadata.format ?? "") || (metadata.pages ?? 1) !== 1) throw new Error("Use one static PNG or JPEG photograph.");
+const sourceWidth = metadata.autoOrient.width;
+const sourceHeight = metadata.autoOrient.height;
+if (!Number.isInteger(sourceWidth) || !Number.isInteger(sourceHeight) || sourceWidth < 16 || sourceHeight < 16 || sourceWidth * sourceHeight > maxPixels) throw new Error("The decoded plate must be at least 16 pixels per side and at most 33 megapixels.");
+const scale = Math.min(1, maxWidth / sourceWidth, maxHeight / sourceHeight);
+const width = Math.floor(sourceWidth * scale / 2) * 2;
+const height = Math.floor(sourceHeight * scale / 2) * 2;
+if (width < 2 || height < 2 || width * height > maxPixels) throw new Error("The requested aspect ratio does not fit a bounded even raster.");
+const sourceSha256 = createHash("sha256").update(bytes).digest("hex");
+const extension = metadata.format === "png" ? "png" : "jpg";
+const outputRoot = join(root, "artifacts/style-portfolio/film-plate");
+await mkdir(outputRoot, { recursive: true });
+if (await realpath(outputRoot) !== outputRoot) throw new Error("The output directory and its parents must not be symlinks.");
+const output = join(outputRoot, run);
+// The run directory is the exclusive claim. A previous or ambiguous run is
+// never overwritten or automatically resumed, even when only planning failed.
+try { await mkdir(output); }
+catch (error) {
+  if ((error as NodeJS.ErrnoException).code === "EEXIST") throw new Error(`Run ${run} already exists. Inspect its intent, log, and host receipts; no overwrite or retry was made.`);
+  throw error;
+}
+const retainedPlate = join(output, `plate.${extension}`);
+await writeFile(retainedPlate, bytes, { flag: "wx", mode: 0o600 });
+const retainedRelative = relative(root, retainedPlate).split(sep).join("/");
+if (isAbsolute(retainedRelative) || retainedRelative.startsWith("../")) throw new Error("The retained plate must stay inside the repository artifacts directory.");
+const source = HtmlSceneInputSchema.parse({
+  kind: "slopcamera.html-scene", schemaVersion: 1,
+  name: "Single-image film-transfer study",
+  document: { path: "examples/style-portfolio/film-plate.html" },
+  canvas: { width, height, deviceScaleFactor: 1 },
+  timing: { durationUs: 6_000_000, fps: 16 },
+  seed: 19060414, background: "#000000", libraries: [],
+  parameters: { kind: "single-image-film-transfer", sourceWidth, sourceHeight, sourceSha256 },
+  resources: [{ name: "plate", path: retainedRelative, urlPath: `assets/plate.${extension}`, mediaType: metadata.format === "png" ? "image/png" : "image/jpeg" }],
+});
+const requestPath = join(output, "scene.json");
+const intentPath = join(output, "intent.json");
+await writeFile(requestPath, JSON.stringify(source, null, 2) + "\n", { flag: "wx" });
+const intent = {
+  kind: "slopcamera.single-image-film-transfer-intent", schemaVersion: 1,
+  mode: dryRun ? "plan" : "render", input, sourceSha256, sourceBytes: bytes.length,
+  sourceDimensions: { width: sourceWidth, height: sourceHeight }, outputDimensions: { width, height },
+  requestedMaximum: { width: maxWidth, height: maxHeight }, retainedPlate: retainedRelative,
+  requestPath, timing: source.timing,
+  limitations: ["One photographic image with optical movement; no subject animation.", "Delivery never exceeds input dimensions. A small optical crop is resampled within that raster.", "Grain and diffusion are a separate explicit finishing operation."],
+};
+await writeFile(intentPath, JSON.stringify(intent, null, 2) + "\n", { flag: "wx" });
+const argv = [process.execPath, join(root, "apps/desktop/dist/cli/main.js"), "html", "render", "--input", requestPath, "--json"];
+if (dryRun) argv.push("--dry-run");
+const logPath = join(output, "render.log");
+const log = await open(logPath, "wx", 0o600);
+let code: number;
+let stdout: string;
+try {
+  const child = Bun.spawn(argv, { cwd: root, env: process.env, stdout: "pipe", stderr: log.fd });
+  const result = await Promise.all([child.exited, new Response(child.stdout).text()]);
+  [code, stdout] = result;
+} finally { await log.close(); }
+if (code !== 0) {
+  await writeFile(join(output, "failed.json"), JSON.stringify({ code, stdout }, null, 2) + "\n", { flag: "wx" });
+  throw new Error(`Slopcamera ${dryRun ? "plan" : "render"} failed (${code}); inspect ${logPath} and retained host receipts. No retry was made.`);
+}
+const result: unknown = JSON.parse(stdout);
+const resultPath = join(output, dryRun ? "plan.json" : "result.json");
+await writeFile(resultPath, JSON.stringify(result, null, 2) + "\n", { flag: "wx" });
+if (!dryRun) {
+  const completion = z.object({ kind: z.literal("slopcamera.html-scene-export"), verification: z.object({ width: z.number(), height: z.number(), frameCount: z.number(), durationUs: z.number() }) }).parse(result);
+  if (completion.verification.width !== width || completion.verification.height !== height || completion.verification.frameCount !== 96 || completion.verification.durationUs !== 6_000_000) throw new Error("Rendered dimensions or timing differ from the admitted request; retain this result for review.");
+}
+console.log(JSON.stringify({ state: dryRun ? "planned" : "rendered", interpretation: "single-image-film-transfer", sourceDimensions: intent.sourceDimensions, dimensions: { width, height }, fps: 16, durationSeconds: 6, sourceSha256, resultPath, intentPath }));

package/examples/style-portfolio/render.ts

@@ -0,0 +1,89 @@
+/** Render original style studies through the canonical Slopcamera host. */
+import { mkdir, open, realpath, writeFile } from "node:fs/promises";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { getVisualStyleProfile } from "../../src/visual-style";
+
+const root = resolve(dirname(fileURLToPath(import.meta.url)), "../..");
+const studies = ["theatrical-cel", "watercolor-storybook", "pixel-art", "math-explainer",
+  "midcentury-limited", "rubber-hose", "cut-paper", "stopmotion-clay", "engraving",
+  "ink-sketch", "rotoscope", "clean-motion"] as const;
+export async function renderStudies(args: readonly string[], workspaceRoot = root, log: (message: string) => void = console.log): Promise<void> {
+  const flagNames = new Set(["--style", "--width", "--offset", "--run"]);
+  const options = new Map<string, string>();
+  const flags = new Set<string>();
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i]!;
+    if (arg === "--all" || arg === "--still" || arg === "--dry-run") {
+      if (flags.has(arg)) throw new Error(`Duplicate flag ${arg}`);
+      flags.add(arg);
+    } else if (flagNames.has(arg) && args[i + 1] !== undefined) {
+      if (options.has(arg)) throw new Error(`Duplicate option ${arg}`);
+      options.set(arg, args[++i]!);
+    } else throw new Error(`Unknown or incomplete option ${arg}`);
+  }
+  const still = flags.has("--still");
+  const width = Number(options.get("--width") ?? 3840);
+  const offset = Number(options.get("--offset") ?? (still ? 3 : 0));
+  const run = options.get("--run") ?? (still ? "stills" : "films");
+  if (!/^[a-z0-9][a-z0-9-]{0,63}$/u.test(run)) throw new Error("--run must be a short lowercase filename token.");
+  if (![1280, 1920, 2560, 3840].includes(width)) throw new Error("--width must be 1280, 1920, 2560, or 3840.");
+  if (!Number.isFinite(offset) || offset < 0 || offset >= 6 || (!still && offset !== 0)) throw new Error("--offset must be in [0,6), and requires --still.");
+  const requested = options.get("--style");
+  if ((requested === undefined) === !flags.has("--all")) throw new Error("Choose exactly one of --style <id> or --all.");
+  const selected = requested === undefined ? studies : studies.filter(id => id === requested);
+  if (selected.length === 0) throw new Error(`Study not found. Choose: ${studies.join(", ")}`);
+  const canonicalRoot = await realpath(workspaceRoot);
+  const output = join(canonicalRoot, "artifacts", "style-portfolio", run);
+  await mkdir(output, { recursive: true });
+  if (await realpath(output) !== output) throw new Error("Output directories must not be symlinks.");
+  for (const style of selected) {
+    // Plans have their own immutable attempt, so inspecting a new width never
+    // replaces an execution's scene, log, result, or native receipt references.
+    const prefix = `${style}${flags.has("--dry-run") ? ".plan" : ""}`;
+    const resultPath = join(output, `${prefix}.result.json`);
+    const requestPath = join(output, `${prefix}.scene.json`);
+    const intentPath = join(output, `${prefix}.intent.json`);
+    // A retained intent without a result is ambiguous. Inspect its log and host
+    // receipts before selecting an explicitly new --run, never auto-resubmit.
+    try {
+      await writeFile(intentPath, JSON.stringify({ kind: "slopcamera.style-study-intent", style, requestPath, width, still,
+        mode: flags.has("--dry-run") ? "plan" : "render" }) + "\n", { flag: "wx", mode: 0o600 });
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code !== "EEXIST") throw error;
+      log(JSON.stringify({ style, state: "already-attempted", intentPath, resultPath }));
+      continue;
+    }
+    const profile = getVisualStyleProfile(style);
+    const scene = {
+      kind: "slopcamera.html-scene", schemaVersion: 1,
+      name: `${profile.name} / ${still ? "master still" : "motion study"}`,
+      document: { path: "examples/style-portfolio/animation-studies.html" },
+      canvas: { width, height: width * 9 / 16, deviceScaleFactor: 1 },
+      timing: { durationUs: still ? 1 : 6_000_000, fps: 24 },
+      seed: 20260923, libraries: [], resources: [],
+      parameters: { style, direction: profile, timeOffsetSeconds: offset },
+      background: profile.palette.background,
+    };
+    await writeFile(requestPath, JSON.stringify(scene, null, 2) + "\n", { flag: "wx", mode: 0o600 });
+    const childArgs = [process.execPath, join(canonicalRoot, "apps/desktop/dist/cli/main.js"), "html", "render", "--input", requestPath, "--json"];
+    if (flags.has("--dry-run")) childArgs.push("--dry-run");
+    const logPath = join(output, `${prefix}.log`);
+    const logFile = await open(logPath, "wx", 0o600);
+    let code: number;
+    let stdout: string;
+    try {
+      const child = Bun.spawn(childArgs, { cwd: canonicalRoot, env: process.env, stdout: "pipe", stderr: logFile.fd });
+      [code, stdout] = await Promise.all([child.exited, new Response(child.stdout).text()]);
+    } finally { await logFile.close(); }
+    if (code !== 0) {
+      await writeFile(join(output, `${prefix}.failed.json`), JSON.stringify({ code, stdout }) + "\n", { flag: "wx" });
+      throw new Error(`${style} render failed (${code}); inspect ${logPath}. No automatic retry was made.`);
+    }
+    const result: unknown = JSON.parse(stdout);
+    await writeFile(resultPath, JSON.stringify(result, null, 2) + "\n", { flag: "wx" });
+    log(JSON.stringify({ style, state: flags.has("--dry-run") ? "planned" : "rendered", resultPath }));
+  }
+}
+
+if (import.meta.main) await renderStudies(process.argv.slice(2));

package/examples/style-portfolio/verify-animation-source.mjs

@@ -0,0 +1,94 @@
+/** Source checks only. This does not replace rendered-frame and motion review. */
+import assert from "node:assert/strict";
+import { createHash } from "node:crypto";
+import { readFile } from "node:fs/promises";
+import { runInNewContext } from "node:vm";
+import { getVisualStyleProfile } from "../../src/visual-style.ts";
+
+const html = await readFile(new URL("./animation-studies.html", import.meta.url), "utf8");
+const scripts = [...html.matchAll(/<script\s*>([\s\S]*?)<\/script\s*>/giu)];
+assert.equal((html.match(/<script\b/giu) ?? []).length, 1, "The self-contained scene has one script element.");
+assert.equal(scripts.length, 1, "The scene script is inline and has no attributes.");
+const script = scripts[0]?.[1];
+assert.ok(script, "The inline scene script is nonempty.");
+new Function(script);
+let digest = createHash("sha256");
+const contexts = [];
+const record = (name, values) => digest.update(JSON.stringify([name, values]));
+function context(name) {
+  let depth = 0;
+  const methods = {
+    save() { depth++; record(`${name}.save`, []); },
+    restore() { assert.ok(depth > 0, "Canvas restore has an owned save."); depth--; record(`${name}.restore`, []); },
+    createLinearGradient(...args) { return gradient("linear", args); },
+    createRadialGradient(...args) { return gradient("radial", args); },
+  };
+  const gradient = (kind, args) => {
+    args.forEach(value => assert.ok(Number.isFinite(value), "Gradient coordinates are finite."));
+    const result = { kind, args, stops: [], addColorStop(position, color) {
+      assert.ok(position >= 0 && position <= 1, "Gradient stop lies in [0, 1].");
+      result.stops.push([position, color]);
+    } };
+    return result;
+  };
+  const proxy = new Proxy(methods, {
+    get(target, property) {
+      if (property in target) return target[property];
+      return (...args) => {
+        for (const value of args) if (typeof value === "number") assert.ok(Number.isFinite(value), `${String(property)} receives finite coordinates.`);
+        if (property === "arc") assert.ok(args[2] >= 0, "Arc radius is nonnegative.");
+        if (property === "ellipse") assert.ok(args[2] >= 0 && args[3] >= 0, "Ellipse radii are nonnegative.");
+        record(`${name}.${String(property)}`, args);
+      };
+    },
+    set(target, property, value) { target[property] = value; record(`${name}.${String(property)}=`, [value]); return true; },
+  });
+  contexts.push(() => assert.equal(depth, 0, "Scene leaves a balanced Canvas save stack."));
+  return proxy;
+}
+const main = { width: 1920, height: 1080, getContext: () => context("main") };
+const pixel = { width: 320, height: 180, getContext: () => context("pixel") };
+let frame;
+const host = { parameters: { style: "theatrical-cel" }, onFrame(callback) { frame = callback; } };
+const window = { innerWidth: 1920, innerHeight: 1080, devicePixelRatio: 1, SlopcameraOverlay: host };
+runInNewContext(script, {
+  window, SlopcameraOverlay: host,
+  document: { getElementById: () => main, createElement: tag => { assert.equal(tag, "canvas"); return pixel; } },
+  Path2D: class { constructor(data) { assert.equal(typeof data, "string"); assert.ok(!/NaN|Infinity/u.test(data), "Path coordinates are finite."); this.data = data; } },
+}, { timeout: 10_000 });
+const drawing = window.PortfolioDrawing;
+assert.equal(drawing.styles.length, 12);
+const fingerprint = (time, style, direction) => {
+  digest = createHash("sha256");
+  drawing.render(time, style, direction);
+  contexts.forEach(check => check());
+  return digest.digest("hex");
+};
+let samples = 0;
+for (const style of drawing.styles) {
+  const profile = getVisualStyleProfile(style);
+  drawing.validateDirection(profile, style);
+  for (const time of [0, .25, .84, 1.68, 2.65, 3, 5.999, 6]) {
+    const first = fingerprint(time, style, profile);
+    fingerprint((time + 1.3) % 6, "clean-motion", getVisualStyleProfile("clean-motion"));
+    assert.equal(fingerprint(time, style, profile), first, `${style} at ${time}s is independent of seek order.`);
+    samples++;
+  }
+}
+assert.throws(() => drawing.render(1, "unknown"), /Unsupported style/u);
+assert.throws(() => drawing.render(NaN, "theatrical-cel"), /finite number/u);
+assert.throws(() => drawing.render(-1, "theatrical-cel"), /finite number/u);
+assert.throws(() => drawing.render(6.1, "theatrical-cel"), /finite number/u);
+assert.throws(() => drawing.validateDirection({}, "theatrical-cel"), /required/u);
+assert.throws(() => drawing.validateDirection({ ...getVisualStyleProfile("theatrical-cel"), id: "pixel-art" }, "theatrical-cel"), /must match/u);
+assert.throws(() => drawing.validateDirection({ ...getVisualStyleProfile("theatrical-cel"), unsupported: 1 }, "theatrical-cel"), /unsupported/u);
+assert.throws(() => drawing.validateDirection({ ...getVisualStyleProfile("theatrical-cel"), cadence: { ...getVisualStyleProfile("theatrical-cel").cadence, fps: 0 } }, "theatrical-cel"), /integer/u);
+window.innerWidth = Infinity;
+assert.throws(() => drawing.render(0, "theatrical-cel"), /canvas CSS width/u);
+window.innerWidth = 1920;
+window.devicePixelRatio = 9;
+assert.throws(() => drawing.render(0, "theatrical-cel"), /devicePixelRatio/u);
+window.devicePixelRatio = 1;
+assert.throws(() => frame({ timeMs: -1 }), /timeMs/u);
+assert.throws(() => frame({ timeMs: 6001 }), /timeMs/u);
+console.log(`Passed: 12 canonical profiles, ${samples} deterministic drawing-command samples, balanced Canvas stacks, finite geometry, and invalid-input checks. Pixel and motion quality still require real renders.`);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@hraness/slopcamera",
-  "version": "3.3.6",
-  "description": "A local visual studio for coding agents: author scenes, combine generated and recorded media, and export images, diagrams, animation, and video from retained sources.",
+  "version": "3.5.0",
+  "description": "Slopcamera lets your coding agent make images, diagrams, animation, 3D scenes, and video from source files it can keep revising.",
   "license": "MIT",
   "type": "module",
   "sideEffects": [
@@ -65,7 +65,6 @@
     "video-generation",
     "video-editing",
     "image-generation",
-    "screen-recording",
     "motion-graphics",
     "captions",
     "speech-generation",
@@ -162,6 +161,15 @@
     "examples/studio/hybrid-scene.ts",
     "examples/html/*.html",
     "examples/html/*.json",
+    "examples/style-portfolio/**/*.html",
+    "examples/style-portfolio/**/*.ts",
+    "examples/style-portfolio/**/*.mjs",
+    "!examples/style-portfolio/**/*.test.ts",
+    "examples/style-portfolio/**/*.py",
+    "examples/style-portfolio/**/*.json",
+    "examples/style-portfolio/**/*.md",
+    "examples/style-portfolio/**/*.woff2",
+    "examples/style-portfolio/**/*.txt",
     "examples/studio/vgpu/heat-field.mjs",
     "apps/desktop/studio/assets/README.md",
     "!apps/desktop/cli/**/*.test.ts",
@@ -227,8 +235,9 @@
     "benchmark:code-concurrency": "bun run ./apps/desktop/code/concurrency-benchmark.ts",
     "check:release-workflows": "bun test ./scripts/release-workflow.test.ts ./scripts/github-release.test.ts",
     "check:schema": "bun run ./scripts/validate-schema.ts",
-    "check:skill": "bun run ./scripts/validate-skill.ts && bun test ./scripts/social-collage-compositor.test.ts",
+    "check:skill": "bun run ./scripts/validate-skill.ts && bun test ./scripts/social-collage-compositor.test.ts && bun examples/style-portfolio/verify-animation-source.mjs",
     "check:standalone": "bun test ./scripts/standalone-support-fixture.test.ts && bun run ./scripts/check-standalone.ts",
+    "check:copy": "bun test ./scripts/check-copy.test.ts && bun run ./scripts/check-copy.ts",
     "test:vectorize:official": "bun run ./scripts/official-vectorizer-smoke.ts",
     "test:package": "bun run ./scripts/package-smoke.ts",
     "check:sdk": "bun run typecheck:sdk && bun run lint:sdk && bun run build:sdk && bun run test:sdk && bun run check:release-workflows && bun run check:schema && bun run check:skill",
@@ -239,7 +248,7 @@
     "kb:check": "bunx --bun github:hraness/kb#v0.15.2 check --root kb && bunx --bun github:hraness/kb#v0.15.2 agents check --root kb --repo .",
     "kb:catalog": "bunx --bun github:hraness/kb#v0.15.2 catalog --root kb",
     "check:cost-surfaces": "bun ./scripts/check-cost-surfaces.mjs",
-    "check": "bun run check:cost-surfaces && bun run check:standalone && bun run check:sdk && bun run check:desktop && bun run check:api && bun run check:web && bun run check:standalone && bun run test:package",
+    "check": "bun run check:cost-surfaces && bun run check:standalone && bun run check:copy && bun run check:sdk && bun run check:desktop && bun run check:api && bun run check:web && bun run check:standalone && bun run test:package",
     "prepack": "bun run check",
     "check:effect": "bun run ./scripts/check-effect-policy.ts && bun test ./scripts/check-effect-architecture.test.ts",
     "typecheck:api": "tsc --noEmit -p apps/api/tsconfig.json",

package/skills/slopcamera/SKILL.md

@@ -1,12 +1,20 @@
 ---
 name: slopcamera
-description: Create, inspect, edit and render visual media with the Slopcamera CLI and SDK. Use for diagrams, raster-to-SVG conversion, screen or camera recordings, video editing and captions, social collage banners, music videos from authored scenes and local tracks, AI images/video/speech/transcription, Three.js scenes and world-space media, Blender rigs and simulation, CadQuery models, parametric architectural designs, Manim educational films, HTML/WGSL motion graphics, and durable agent workflows.
+description: Create, inspect, edit and render visual media with the Slopcamera CLI and SDK. Use for diagrams, raster-to-SVG conversion, existing screen or camera recordings, video editing and captions, social collage banners, music videos from authored scenes and local tracks, AI images/video/speech/transcription, Three.js scenes and world-space media, Blender rigs and simulation, CadQuery models, parametric architectural designs, Manim educational films, HTML/WGSL motion graphics, and durable agent workflows.
 ---
 
 # Create visual media with Slopcamera
 
 Start from the requested result and existing source. Use the installed `slopcamera` CLI, inspect its real capabilities and retain the authored source beside its derived media. Read only the references needed by the task.
 
+For creative film and animation, choose coherent art direction before rendering.
+Use [visual style direction](references/visual-style-direction.md) for historical
+footage, animation families, resolution, and visual review. Default to native 4K
+for an unspecified creative master when the renderer and source support it;
+preserve deliberate pixel grids, period aspect ratios, source limits, and the
+user's explicit settings. Treat quality as staging,
+materials, movement, and finishing together.
+
 ## Establish the host
 
 Run `slopcamera --help` and use `slopcamera doctor --json` for the selected local tools. If installation or a version mismatch blocks the task, read [installation and readiness](references/install.md). A skill installation does not install the CLI or native engines.
@@ -17,14 +25,16 @@ Slopcamera installs from its verified release archive or from source. Historical
 
 | Requested result | Read |
 | --- | --- |
+| Historical film, cel animation, pixel art, classic animation styles, or a demo portfolio | [Visual style direction](references/visual-style-direction.md) |
 | Editable diagram, flowchart or visual explanation | [Diagrams](references/diagrams.md) and [visual communication](references/visual-communication.md) |
-| Patent-style drawing sheets, physical margins, monochrome SVGs or a drawing PDF | [Drawing sheets](references/patent-drawings.md); requires current source |
+| Patent-style drawing sheets, physical margins, monochrome SVGs or a drawing PDF | [Drawing sheets](references/patent-drawings.md) |
 | Custom diagram themes, fonts or icon packages | [Customization](references/customization.md) |
 | Raster artwork converted to SVG | [Vectorization](references/vectorization.md) |
-| Record, clean up, caption, frame or deliver video | [Video projects](references/video-projects.md) |
+| Clean up, caption, frame, or deliver existing recordings and footage | [Video projects](references/video-projects.md) |
 | Music video, dancing mascot or timed HTML scene with a local soundtrack | [Music videos](references/music-video.md) |
 | Authorized YouTube or other public web-media excerpt (`yt-dlp` / `youtube-dl`) | [Web-media excerpts](references/web-media-excerpts.md) |
 | Generate images, clips, narration or transcripts | [Gateway media](references/gateway-media.md) |
+| Product mark, marketing illustration or topic icon | [Brand illustrations](references/brand-illustrations.md) |
 | Compose an editorial or social banner from generated layers, local type and diagrams | [Social collage banners](references/social-collage-banners.md) |
 | Review alternative textures, skyboxes, backdrops, design candidates or whole-scene variants | [Image galleries](references/image-galleries.md) |
 | Budgeted short clips, reviewed takes and continuity | [Directing video](references/directing-video.md) |