@drawcall/design 0.1.0

package/README.md

@@ -0,0 +1,25 @@
+# @drawcall/design
+
+The Drawcall Design v1 API contract and its remote CLI.
+
+```ts
+import { v1 } from "@drawcall/design";
+
+const design = v1.createClient({ authToken: process.env.DRAWCALL_AUTH_TOKEN });
+const projects = await design.project.list();
+```
+
+```sh
+npx @drawcall/design login
+npx @drawcall/design skill
+npx @drawcall/design project create showroom
+npx @drawcall/design frame create showroom/chair --size 800x800 'import * as THREE from "three"; export const scene = new THREE.Group()'
+npx @drawcall/design frame create showroom/reference --size 800x800 --image ./reference.png
+npx @drawcall/design frame create showroom/mood --size 800x800 --image https://example.com/mood.webp
+npx @drawcall/design frame screenshot showroom/chair
+```
+
+Source is always remote. Commands accept inline text or stdin; there is no checkout or local project
+linking. `frame source replace` accepts a `Record<path, code>` JSON object inline or on stdin.
+Agents should read `npx @drawcall/design skill` before creating or changing code-frame source. MCP
+clients get the same text from `get_skill`.

package/dist/cli-client.d.ts

@@ -0,0 +1,5 @@
+import { type DesignV1Client } from "./v1/client.js";
+export declare class NotLoggedInError extends Error {
+    constructor();
+}
+export declare function getCliClient(baseUrlOverride?: string): Promise<DesignV1Client>;

package/dist/cli-client.js

@@ -0,0 +1,19 @@
+import { loadConfig } from "./config.js";
+import { createClient, DEFAULT_BASE_URL, } from "./v1/client.js";
+export class NotLoggedInError extends Error {
+    constructor() {
+        super("Not logged in. Run `npx @drawcall/design login` first.");
+        this.name = "NotLoggedInError";
+    }
+}
+export async function getCliClient(baseUrlOverride) {
+    const config = await loadConfig();
+    const authToken = process.env.DRAWCALL_AUTH_TOKEN ?? config?.authToken;
+    if (!authToken)
+        throw new NotLoggedInError();
+    const baseUrl = baseUrlOverride ??
+        process.env.DESIGN_API_URL ??
+        config?.baseUrl ??
+        DEFAULT_BASE_URL;
+    return createClient({ baseUrl, authToken });
+}

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,332 @@
+#!/usr/bin/env node
+import { createRequire } from "node:module";
+import { Command, Option } from "commander";
+import { clearConfig, getConfigPath, saveConfig } from "./config.js";
+import { getCliClient } from "./cli-client.js";
+import { readImageInput } from "./image.js";
+import { designSkill } from "./skill.generated.js";
+import { parseFrameSize, parseFrameTarget, parseScreenshotTarget, parseSourceFiles, } from "./target.js";
+import { createClient, DEFAULT_BASE_URL } from "./v1/client.js";
+const AUTH_ISSUER_URL = "https://auth.drawcall.ai/api/auth";
+const DEVICE_CLIENT_ID = "drawcall-cli";
+function sourceInput(source) {
+    return source === undefined ? {} : { source: { "/index.ts": source } };
+}
+const program = new Command()
+    .name("design")
+    .description("Design 3D scenes on Drawcall Design")
+    .version(readPackageVersion())
+    .addOption(new Option("--api <url>", "Design API URL").default(process.env.DESIGN_API_URL, "from DESIGN_API_URL / config / default"));
+program
+    .command("skill")
+    .description("Print the Drawcall Design skill")
+    .action(() => {
+    process.stdout.write(designSkill);
+});
+program
+    .command("login")
+    .description("Sign in with your Drawcall account")
+    .action(async (_options, command) => {
+    const baseUrlOverride = apiOption(command);
+    const baseUrl = baseUrlOverride ?? DEFAULT_BASE_URL;
+    const token = await runDeviceLogin();
+    const client = createClient({ baseUrl, authToken: token });
+    const user = await client.user.me();
+    await saveConfig(baseUrlOverride ? { authToken: token, baseUrl } : { authToken: token });
+    console.log(`Signed in as ${user.email}. Credentials saved to ${getConfigPath()}.`);
+});
+program
+    .command("logout")
+    .description("Sign out")
+    .action(async () => {
+    console.log((await clearConfig()) ? "Signed out." : "Already signed out.");
+});
+const project = program.command("project").description("Manage projects");
+project
+    .command("list")
+    .description("List projects")
+    .action(async (_options, command) => {
+    const client = await clientFor(command);
+    const projects = await client.project.list();
+    if (projects.length === 0) {
+        console.log("No projects.");
+        return;
+    }
+    for (const item of projects)
+        console.log(`${item.name}\t${item.id}`);
+});
+project
+    .command("create")
+    .description("Create a project")
+    .argument("<name>", "Project name")
+    .action(async (name, _options, command) => {
+    const client = await clientFor(command);
+    const created = await client.project.create({ name });
+    console.log(`Created ${created.name}\t${created.id}`);
+});
+project
+    .command("delete")
+    .description("Delete a project")
+    .argument("<name>", "Project name")
+    .option("-y, --yes", "Confirm deletion", false)
+    .action(async (name, options, command) => {
+    requireConfirmation(options.yes);
+    const client = await clientFor(command);
+    await client.project.delete({ project: name });
+    console.log(`Deleted ${name}.`);
+});
+const frame = program.command("frame").description("Manage frames");
+frame
+    .command("list")
+    .description("List frames in a project")
+    .argument("<project>", "Project name")
+    .action(async (projectName, _options, command) => {
+    const client = await clientFor(command);
+    const frames = await client.frame.list({ project: projectName });
+    if (frames.length === 0) {
+        console.log("No frames.");
+        return;
+    }
+    for (const item of frames) {
+        console.log(`${item.name}\t${item.kind}\t${item.width}x${item.height}\t${item.id}`);
+    }
+});
+frame
+    .command("create")
+    .description("Create a code or image frame")
+    .argument("<target>", "Project and frame as <project>/<frame>")
+    .argument("[source]", "Inline /index.ts source, or - to read it from stdin")
+    .requiredOption("-s, --size <width>x<height>", "Authoritative frame size")
+    .option("--image <url-or-path>", "Create an image frame from a URL or file")
+    .action(async (targetValue, sourceValue, options, command) => {
+    const target = parseFrameTarget(targetValue);
+    const size = parseFrameSize(options.size);
+    if (options.image !== undefined && sourceValue !== undefined) {
+        throw new Error("Source and --image cannot be used together");
+    }
+    const client = await clientFor(command);
+    const created = options.image === undefined
+        ? await client.frame.create({
+            project: target.project,
+            name: target.frame,
+            kind: "code",
+            ...size,
+            ...sourceInput(await optionalIndexSource(sourceValue)),
+        })
+        : await client.frame.create({
+            project: target.project,
+            name: target.frame,
+            kind: "image",
+            image: await readImageInput(options.image),
+            ...size,
+        });
+    console.log(`Created ${targetValue}\t${created.id}`);
+});
+frame
+    .command("rename")
+    .description("Rename a frame")
+    .argument("<target>", "Project and frame as <project>/<frame>")
+    .argument("<name>", "New frame name")
+    .action(async (targetValue, name, _options, command) => {
+    const client = await clientFor(command);
+    const renamed = await client.frame.rename({
+        ...parseFrameTarget(targetValue),
+        name,
+    });
+    console.log(`Renamed ${targetValue} to ${renamed.name}.`);
+});
+frame
+    .command("delete")
+    .description("Delete one or more frames")
+    .argument("<targets...>", "Frames as <project>/<frame>")
+    .option("-y, --yes", "Confirm deletion", false)
+    .action(async (targets, options, command) => {
+    requireConfirmation(options.yes);
+    const client = await clientFor(command);
+    for (const targetValue of targets) {
+        await client.frame.delete(parseFrameTarget(targetValue));
+        console.log(`Deleted ${targetValue}.`);
+    }
+});
+frame
+    .command("screenshot")
+    .description("Render frames and print their screenshot URLs")
+    .argument("<targets...>", "Projects or frames as <project> or <project>/<frame>")
+    .action(async (targets, _options, command) => {
+    const client = await clientFor(command);
+    for (const value of targets)
+        await screenshotTarget(client, value);
+});
+const source = frame.command("source").description("Manage code-frame source");
+source
+    .command("list")
+    .description("List source paths")
+    .argument("<target>", "Project and frame as <project>/<frame>")
+    .action(async (targetValue, _options, command) => {
+    const client = await clientFor(command);
+    const result = await client.frame.source.list(parseFrameTarget(targetValue));
+    for (const path of result.paths)
+        console.log(path);
+});
+source
+    .command("read")
+    .description("Read one source file")
+    .argument("<target>", "Project and frame as <project>/<frame>")
+    .argument("<path>", "Absolute source path")
+    .action(async (targetValue, path, _options, command) => {
+    const client = await clientFor(command);
+    const result = await client.frame.source.read({
+        ...parseFrameTarget(targetValue),
+        path,
+    });
+    process.stdout.write(result.code);
+});
+source
+    .command("write")
+    .description("Create or replace one source file")
+    .argument("<target>", "Project and frame as <project>/<frame>")
+    .argument("<path>", "Absolute source path")
+    .argument("[code]", "Inline code; omit or use - to read stdin")
+    .action(async (targetValue, path, codeValue, _options, command) => {
+    const code = codeValue === undefined || codeValue === "-"
+        ? await readStdin()
+        : codeValue;
+    const client = await clientFor(command);
+    await client.frame.source.write({
+        ...parseFrameTarget(targetValue),
+        path,
+        code,
+    });
+    console.log(`Wrote ${path}.`);
+});
+source
+    .command("edit")
+    .description("Replace text that occurs exactly once in one source file")
+    .argument("<target>", "Project and frame as <project>/<frame>")
+    .argument("<path>", "Absolute source path")
+    .argument("<old-text>", "Text that must occur exactly once")
+    .argument("<new-text>", "Replacement text")
+    .action(async (targetValue, path, oldText, newText, _options, command) => {
+    const client = await clientFor(command);
+    await client.frame.source.edit({
+        ...parseFrameTarget(targetValue),
+        path,
+        oldText,
+        newText,
+    });
+    console.log(`Edited ${path}.`);
+});
+source
+    .command("replace")
+    .description("Replace all source files from a Record<path, code> JSON object")
+    .argument("<target>", "Project and frame as <project>/<frame>")
+    .argument("[files]", "Inline JSON, or omit/use - to read stdin")
+    .action(async (targetValue, filesValue, _options, command) => {
+    const input = filesValue === undefined || filesValue === "-"
+        ? await readStdin()
+        : filesValue;
+    const client = await clientFor(command);
+    await client.frame.source.replace({
+        ...parseFrameTarget(targetValue),
+        files: parseSourceFiles(input),
+    });
+    console.log("Replaced source.");
+});
+source
+    .command("delete")
+    .description("Delete exact source paths, or all source with a quoted *")
+    .argument("<target>", "Project and frame as <project>/<frame>")
+    .argument("<paths...>", "Absolute paths, or quoted *")
+    .option("-y, --yes", "Confirm deletion", false)
+    .action(async (targetValue, paths, options, command) => {
+    requireConfirmation(options.yes);
+    const client = await clientFor(command);
+    await client.frame.source.delete({
+        ...parseFrameTarget(targetValue),
+        paths,
+    });
+    console.log("Deleted source.");
+});
+if (process.argv.length <= 2) {
+    program.outputHelp();
+}
+else {
+    program.parseAsync().catch((error) => {
+        console.error(error instanceof Error ? error.message : String(error));
+        process.exitCode = 1;
+    });
+}
+async function clientFor(command) {
+    return getCliClient(apiOption(command));
+}
+function apiOption(command) {
+    const value = command.optsWithGlobals().api;
+    return typeof value === "string" ? value : undefined;
+}
+function requireConfirmation(confirmed) {
+    if (!confirmed)
+        throw new Error("Destructive commands require --yes.");
+}
+async function optionalIndexSource(value) {
+    if (value === undefined)
+        return undefined;
+    return value === "-" ? readStdin() : value;
+}
+async function readStdin() {
+    const chunks = [];
+    for await (const chunk of process.stdin) {
+        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    }
+    return Buffer.concat(chunks).toString("utf8");
+}
+async function screenshotTarget(client, value) {
+    const target = parseScreenshotTarget(value);
+    if (target.frame) {
+        const result = await client.frame.screenshot(target);
+        console.log(`${value}\t${result.url}`);
+        return;
+    }
+    const frames = await client.frame.list({ project: target.project });
+    for (const item of frames) {
+        const result = await client.frame.screenshot({
+            project: target.project,
+            frame: item.name,
+        });
+        console.log(`${target.project}/${item.name}\t${result.url}`);
+    }
+}
+function readPackageVersion() {
+    const manifest = createRequire(import.meta.url)("../package.json");
+    if (!manifest ||
+        typeof manifest !== "object" ||
+        Array.isArray(manifest) ||
+        !("version" in manifest) ||
+        typeof manifest.version !== "string") {
+        throw new Error("@drawcall/design package.json is missing a valid version");
+    }
+    return manifest.version;
+}
+async function runDeviceLogin() {
+    const [{ default: open }, oauth] = await Promise.all([
+        import("open"),
+        import("openid-client"),
+    ]);
+    const configuration = await oauth.discovery(new URL(AUTH_ISSUER_URL), DEVICE_CLIENT_ID, undefined, oauth.None());
+    const authorization = await oauth.initiateDeviceAuthorization(configuration, {
+        scope: "design",
+    });
+    const verificationUrl = authorization.verification_uri_complete ?? authorization.verification_uri;
+    console.log(`Open ${verificationUrl}`);
+    console.log(`Code: ${authorization.user_code}`);
+    try {
+        await open(verificationUrl);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(`Could not open a browser automatically: ${message}`);
+    }
+    const tokens = await oauth.pollDeviceAuthorizationGrant(configuration, authorization);
+    if (!tokens.access_token)
+        throw new Error("Device login completed without an access token.");
+    return tokens.access_token;
+}

package/dist/config.d.ts

@@ -0,0 +1,11 @@
+import { z } from "zod";
+declare const configSchema: z.ZodObject<{
+    authToken: z.ZodString;
+    baseUrl: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type Config = z.infer<typeof configSchema>;
+export declare function loadConfig(): Promise<Config | null>;
+export declare function saveConfig(config: Config): Promise<void>;
+export declare function clearConfig(): Promise<boolean>;
+export declare function getConfigPath(): string;
+export {};

package/dist/config.js

@@ -0,0 +1,56 @@
+import * as fs from "node:fs/promises";
+import * as os from "node:os";
+import * as path from "node:path";
+import { z } from "zod";
+const configSchema = z.object({
+    authToken: z.string().min(1),
+    baseUrl: z.string().url().optional(),
+});
+function configDirectory() {
+    if (process.platform === "win32" && process.env.APPDATA) {
+        return path.join(process.env.APPDATA, "drawcall-design");
+    }
+    const parent = process.env.XDG_CONFIG_HOME ?? path.join(os.homedir(), ".config");
+    return path.join(parent, "drawcall-design");
+}
+function configPath() {
+    return path.join(configDirectory(), "config.json");
+}
+export async function loadConfig() {
+    try {
+        const value = JSON.parse(await fs.readFile(configPath(), "utf8"));
+        return configSchema.parse(value);
+    }
+    catch (error) {
+        if (isMissingFile(error))
+            return null;
+        throw error;
+    }
+}
+export async function saveConfig(config) {
+    const directory = configDirectory();
+    await fs.mkdir(directory, { recursive: true });
+    await fs.chmod(directory, 0o700);
+    const file = configPath();
+    await fs.writeFile(file, `${JSON.stringify(config, null, 2)}\n`, {
+        mode: 0o600,
+    });
+    await fs.chmod(file, 0o600);
+}
+export async function clearConfig() {
+    try {
+        await fs.unlink(configPath());
+        return true;
+    }
+    catch (error) {
+        if (isMissingFile(error))
+            return false;
+        throw error;
+    }
+}
+export function getConfigPath() {
+    return configPath();
+}
+function isMissingFile(error) {
+    return error instanceof Error && "code" in error && error.code === "ENOENT";
+}

package/dist/image.d.ts

@@ -0,0 +1 @@
+export declare function readImageInput(value: string): Promise<File | string>;

package/dist/image.js

@@ -0,0 +1,25 @@
+import { readFile } from "node:fs/promises";
+import { basename, extname } from "node:path";
+import { imageUrlSchema } from "./v1/schemas.js";
+export async function readImageInput(value) {
+    if (/^https?:/i.test(value) || value.includes("://")) {
+        return imageUrlSchema.parse(value);
+    }
+    const extension = extname(value).toLowerCase();
+    const mediaType = mediaTypeForExtension(extension);
+    if (mediaType === undefined) {
+        throw new Error("Local images must be PNG, JPEG, or WebP files");
+    }
+    return new File([await readFile(value)], basename(value), {
+        type: mediaType,
+    });
+}
+function mediaTypeForExtension(extension) {
+    if (extension === ".jpeg" || extension === ".jpg")
+        return "image/jpeg";
+    if (extension === ".png")
+        return "image/png";
+    if (extension === ".webp")
+        return "image/webp";
+    return undefined;
+}

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export * as v1 from "./v1/index.js";
+export { designSkill } from "./skill.generated.js";
+export { deleteSourceFiles, editSourceCode, editSourceFile, SourceEditError, SourceFileNotFoundError, } from "./source.js";
+export { parseFrameSize, parseFrameTarget, parseScreenshotTarget, parseSourceFiles, type FrameTarget, type ScreenshotTarget, } from "./target.js";
+export { inspectionMessageSchema, projectSyncUrl, type InspectionMessage, } from "./protocol.js";
+export type { CodeFrame, CreateCodeFrame, CreateFrame, CreateImageFrame, Frame, ImageFrame, Project, Screenshot, SourceFile, SourceFiles, SourceList, SourceMutation, User, } from "./v1/schemas.js";

package/dist/index.js

@@ -0,0 +1,5 @@
+export * as v1 from "./v1/index.js";
+export { designSkill } from "./skill.generated.js";
+export { deleteSourceFiles, editSourceCode, editSourceFile, SourceEditError, SourceFileNotFoundError, } from "./source.js";
+export { parseFrameSize, parseFrameTarget, parseScreenshotTarget, parseSourceFiles, } from "./target.js";
+export { inspectionMessageSchema, projectSyncUrl, } from "./protocol.js";

package/dist/protocol.d.ts

@@ -0,0 +1,7 @@
+import { z } from "zod";
+export declare const inspectionMessageSchema: z.ZodObject<{
+    type: z.ZodLiteral<"drawcall:inspection">;
+    enabled: z.ZodBoolean;
+}, z.core.$strip>;
+export type InspectionMessage = z.infer<typeof inspectionMessageSchema>;
+export declare function projectSyncUrl(baseUrl: string, project: string): string;

package/dist/protocol.js

@@ -0,0 +1,15 @@
+import { z } from "zod";
+export const inspectionMessageSchema = z.object({
+    type: z.literal("drawcall:inspection"),
+    enabled: z.boolean(),
+});
+export function projectSyncUrl(baseUrl, project) {
+    const url = new URL(`/api/v1/projects/${encodeURIComponent(project)}/sync`, baseUrl);
+    if (url.protocol === "https:")
+        url.protocol = "wss:";
+    else if (url.protocol === "http:")
+        url.protocol = "ws:";
+    else
+        throw new Error(`Cannot create a WebSocket URL from ${url.protocol}`);
+    return url.href;
+}

package/dist/skill.generated.d.ts

@@ -0,0 +1 @@
+export declare const designSkill = "---\nname: drawcall-design\ndescription: Create, modify, inspect, and screenshot 3D objects and scenes in Drawcall Design using its MCP tools or @drawcall/design CLI. Use for Drawcall Design projects, frames, and code-frame source. Do not use for full games or applications.\n---\n\n# Drawcall Design\n\nUse the Drawcall Design MCP tools when available. Otherwise, use `npx @drawcall/design`. Drawcall Design is a remote, current-state canvas: inspect the existing project, frames, and source before changing them.\n\nA code frame stores source as a `Record<absolute path, code>`. A renderable frame has exactly one `/index.ts` or `/index.js`. That module must export `scene`, whose value is a `THREE.Object3D`, and may export `camera`, whose value is a `THREE.Camera`.\n\nSource runs as browser ESM. Use relative imports with explicit extensions for other frame files and normal package imports for browser-compatible packages. Top-level await is supported. In TypeScript files, use syntax that can be erased; avoid features that generate JavaScript.\n\nA code frame represents a designed state rather than a running application. Complete asynchronous setup before exporting the scene, and add any lighting or environment the object needs.\n\nCreate image frames from a public HTTP(S) URL through MCP. In the CLI, `frame create --image` accepts either an HTTP(S) URL or a local PNG, JPEG, or WebP file.\n\n```ts\nimport * as THREE from \"three\";\n\nconst root = new THREE.Scene();\n// Build the object or scene.\n\nexport const scene: THREE.Object3D = root;\n\nconst view = new THREE.PerspectiveCamera(35, 1, 0.1, 100);\nview.position.set(4, 3, 5);\nview.lookAt(0, 0, 0);\n\nexport const camera: THREE.Camera = view;\n```\n\nRead source before editing it. Prefer an exact edit for a small change, write one file when replacing that file, and replace the complete source only when the whole frame should change.\n\nAfter every meaningful visual change, take a frame screenshot and inspect it. Iterate until the rendered object, composition, and frame size satisfy the request.\n";

package/dist/skill.generated.js

@@ -0,0 +1,2 @@
+// Generated from skills/drawcall-design/SKILL.md.
+export const designSkill = '---\nname: drawcall-design\ndescription: Create, modify, inspect, and screenshot 3D objects and scenes in Drawcall Design using its MCP tools or @drawcall/design CLI. Use for Drawcall Design projects, frames, and code-frame source. Do not use for full games or applications.\n---\n\n# Drawcall Design\n\nUse the Drawcall Design MCP tools when available. Otherwise, use `npx @drawcall/design`. Drawcall Design is a remote, current-state canvas: inspect the existing project, frames, and source before changing them.\n\nA code frame stores source as a `Record<absolute path, code>`. A renderable frame has exactly one `/index.ts` or `/index.js`. That module must export `scene`, whose value is a `THREE.Object3D`, and may export `camera`, whose value is a `THREE.Camera`.\n\nSource runs as browser ESM. Use relative imports with explicit extensions for other frame files and normal package imports for browser-compatible packages. Top-level await is supported. In TypeScript files, use syntax that can be erased; avoid features that generate JavaScript.\n\nA code frame represents a designed state rather than a running application. Complete asynchronous setup before exporting the scene, and add any lighting or environment the object needs.\n\nCreate image frames from a public HTTP(S) URL through MCP. In the CLI, `frame create --image` accepts either an HTTP(S) URL or a local PNG, JPEG, or WebP file.\n\n```ts\nimport * as THREE from "three";\n\nconst root = new THREE.Scene();\n// Build the object or scene.\n\nexport const scene: THREE.Object3D = root;\n\nconst view = new THREE.PerspectiveCamera(35, 1, 0.1, 100);\nview.position.set(4, 3, 5);\nview.lookAt(0, 0, 0);\n\nexport const camera: THREE.Camera = view;\n```\n\nRead source before editing it. Prefer an exact edit for a small change, write one file when replacing that file, and replace the complete source only when the whole frame should change.\n\nAfter every meaningful visual change, take a frame screenshot and inspect it. Iterate until the rendered object, composition, and frame size satisfy the request.\n';

package/dist/source.d.ts

@@ -0,0 +1,10 @@
+import type { SourceFiles } from "./v1/schemas.js";
+export declare class SourceEditError extends Error {
+    constructor(message: string);
+}
+export declare class SourceFileNotFoundError extends Error {
+    constructor(path: string);
+}
+export declare function editSourceCode(code: string, oldText: string, newText: string): string;
+export declare function editSourceFile(files: SourceFiles, path: string, oldText: string, newText: string): SourceFiles;
+export declare function deleteSourceFiles(files: SourceFiles, paths: string[]): SourceFiles;

package/dist/source.js

@@ -0,0 +1,38 @@
+export class SourceEditError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "SourceEditError";
+    }
+}
+export class SourceFileNotFoundError extends Error {
+    constructor(path) {
+        super(`Source file not found: ${path}`);
+        this.name = "SourceFileNotFoundError";
+    }
+}
+export function editSourceCode(code, oldText, newText) {
+    if (oldText.length === 0)
+        throw new SourceEditError("oldText cannot be empty");
+    const match = code.indexOf(oldText);
+    if (match === -1)
+        throw new SourceEditError("oldText does not occur in the source file");
+    if (code.indexOf(oldText, match + 1) !== -1) {
+        throw new SourceEditError("oldText occurs more than once in the source file");
+    }
+    return code.slice(0, match) + newText + code.slice(match + oldText.length);
+}
+export function editSourceFile(files, path, oldText, newText) {
+    const code = files[path];
+    if (code === undefined)
+        throw new SourceFileNotFoundError(path);
+    return { ...files, [path]: editSourceCode(code, oldText, newText) };
+}
+export function deleteSourceFiles(files, paths) {
+    if (paths.length === 1 && paths[0] === "*")
+        return {};
+    for (const path of paths) {
+        if (!Object.hasOwn(files, path))
+            throw new SourceFileNotFoundError(path);
+    }
+    return Object.fromEntries(Object.entries(files).filter(([path]) => !paths.includes(path)));
+}

package/dist/target.d.ts

@@ -0,0 +1,18 @@
+export interface FrameTarget {
+    project: string;
+    frame: string;
+}
+export type ScreenshotTarget = {
+    project: string;
+    frame?: never;
+} | {
+    project: string;
+    frame: string;
+};
+export declare function parseFrameTarget(value: string): FrameTarget;
+export declare function parseScreenshotTarget(value: string): ScreenshotTarget;
+export declare function parseFrameSize(value: string): {
+    width: number;
+    height: number;
+};
+export declare function parseSourceFiles(value: string): Record<string, string>;

package/dist/target.js

@@ -0,0 +1,40 @@
+import { z } from "zod";
+import { frameNameSchema, projectNameSchema, sourceFilesSchema, } from "./v1/schemas.js";
+export function parseFrameTarget(value) {
+    const segments = value.split("/");
+    const project = segments[0];
+    const frame = segments[1];
+    if (segments.length !== 2 || project === undefined || frame === undefined) {
+        throw new Error(`Expected <project>/<frame>, received ${JSON.stringify(value)}`);
+    }
+    return {
+        project: projectNameSchema.parse(project),
+        frame: frameNameSchema.parse(frame),
+    };
+}
+export function parseScreenshotTarget(value) {
+    if (value.includes("/"))
+        return parseFrameTarget(value);
+    return { project: projectNameSchema.parse(value) };
+}
+export function parseFrameSize(value) {
+    const match = /^(\d+)[x×](\d+)$/i.exec(value);
+    const widthText = match?.[1];
+    const heightText = match?.[2];
+    if (widthText === undefined || heightText === undefined) {
+        throw new Error(`Expected <width>x<height>, received ${JSON.stringify(value)}`);
+    }
+    const width = Number(widthText);
+    const height = Number(heightText);
+    if (!Number.isSafeInteger(width) ||
+        !Number.isSafeInteger(height) ||
+        width < 1 ||
+        height < 1) {
+        throw new Error("Frame width and height must be positive safe integers");
+    }
+    return { width, height };
+}
+export function parseSourceFiles(value) {
+    const parsed = JSON.parse(value);
+    return sourceFilesSchema.parse(parsed);
+}

package/dist/v1/client.d.ts

@@ -0,0 +1,10 @@
+import type { ContractRouterClient } from "@orpc/contract";
+import { type V1Contract } from "./contract.js";
+export declare const DEFAULT_BASE_URL = "https://design.drawcall.ai";
+export type DesignV1Client = ContractRouterClient<V1Contract>;
+export interface DesignV1ClientOptions {
+    baseUrl?: string;
+    fetch?: typeof globalThis.fetch;
+    authToken?: string;
+}
+export declare function createClient(options?: DesignV1ClientOptions): DesignV1Client;