@drawcall/design 0.9.1 → 0.10.0

package/dist/mcp/comment.js

@@ -0,0 +1,90 @@
+import { commentBodySchema, createCommentSchema, designIdSchema, } from "../v1/schemas.js";
+import { result } from "./result.js";
+import { projectInput } from "./schema.js";
+const commentInput = projectInput.extend({ comment: designIdSchema });
+export function registerCommentTools(server, client) {
+    server.registerTool("list_design_comments", {
+        title: "List Design comments",
+        description: "List project comments and replies. Optionally limit the result to one frame.",
+        inputSchema: projectInput.extend({ frame: designIdSchema.optional() }),
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            openWorldHint: false,
+            idempotentHint: true,
+        },
+    }, async ({ project, frame }) => result({
+        comments: await client.comment.list({
+            project,
+            ...(frame ? { frame } : {}),
+        }),
+    }));
+    server.registerTool("get_design_comment", {
+        title: "Get Design comment",
+        description: "Get one comment with all of its replies.",
+        inputSchema: commentInput,
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            openWorldHint: false,
+            idempotentHint: true,
+        },
+    }, async ({ project, comment }) => result({ comment: await client.comment.get({ project, comment }) }));
+    server.registerTool("create_design_comment", {
+        title: "Create Design comment",
+        description: "Create a frame-level comment or a positioned annotation. A position requires expectedContentRevision from the current target frame; omit the position when its coordinates are not authoritative.",
+        inputSchema: createCommentSchema,
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: false,
+            openWorldHint: false,
+            idempotentHint: false,
+        },
+    }, async (input) => result({ comment: await client.comment.create(input) }));
+    server.registerTool("reply_to_design_comment", {
+        title: "Reply to Design comment",
+        description: "Add a reply to an unresolved comment.",
+        inputSchema: commentInput.extend({ body: commentBodySchema }),
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: false,
+            openWorldHint: false,
+            idempotentHint: false,
+        },
+    }, async ({ project, comment, body }) => result({
+        comment: await client.comment.reply({ project, comment, body }),
+    }));
+    registerResolutionTool(server, client, true);
+    registerResolutionTool(server, client, false);
+    server.registerTool("delete_design_comment", {
+        title: "Delete Design comment",
+        description: "Permanently delete a comment thread or one reply. Deleting a thread also deletes its replies.",
+        inputSchema: commentInput,
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: true,
+            openWorldHint: false,
+            idempotentHint: false,
+        },
+    }, async ({ project, comment }) => result(await client.comment.delete({ project, comment })));
+}
+function registerResolutionTool(server, client, resolved) {
+    const action = resolved ? "resolve" : "reopen";
+    server.registerTool(`${action}_design_comment`, {
+        title: `${resolved ? "Resolve" : "Reopen"} Design comment`,
+        description: `${resolved ? "Resolve" : "Reopen"} a comment thread.`,
+        inputSchema: commentInput,
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: false,
+            openWorldHint: false,
+            idempotentHint: true,
+        },
+    }, async ({ project, comment }) => result({
+        comment: await client.comment.setResolved({
+            project,
+            comment,
+            resolved,
+        }),
+    }));
+}

package/dist/mcp/frame.js

@@ -15,7 +15,7 @@ export function registerFrameTools(server, client, fetcher) {
     }, async ({ project }) => result({ frames: await client.frame.list({ project }) }));
     server.registerTool("create_design_frame", {
         title: "Create Design frame",
-        description: "Create a frame in a Drawcall Design project. Use type=glts for reusable 3D objects and scenes, then write its source with write_design_file. Use type=image only for an existing public image URL and type=market only for an exact public Market asset.",
+        description: "Create a frame in a Drawcall Design project. Use type=glts for reusable 3D objects and scenes, then write .glts source with write_design_file. Use type=markdown for a document, then write /<frame-id>/index.md. Use type=image only for an existing public image URL and type=market only for an exact public Market asset.",
         inputSchema: createFrameSchema,
         annotations: {
             readOnlyHint: false,

package/dist/mcp/register.js

@@ -1,4 +1,5 @@
 import { registerFileTools } from "./file.js";
+import { registerCommentTools } from "./comment.js";
 import { registerFrameTools } from "./frame.js";
 import { registerProjectTools } from "./project.js";
 import { registerSkillTool } from "./skill.js";
@@ -6,5 +7,6 @@ export function registerDesignTools(server, client, options = {}) {
     registerSkillTool(server);
     registerProjectTools(server, client);
     registerFrameTools(server, client, options.fetch ?? globalThis.fetch);
+    registerCommentTools(server, client);
     registerFileTools(server, client);
 }

package/dist/mcp/schema.d.ts

@@ -10,6 +10,7 @@ export declare const createFrameSchema: z.ZodObject<{
     type: z.ZodEnum<{
         image: "image";
         glts: "glts";
+        markdown: "markdown";
         market: "market";
     }>;
     width: z.ZodOptional<z.ZodCoercedNumber<unknown>>;

package/dist/mcp/schema.js

@@ -12,7 +12,7 @@ export const createFrameSchema = z
     .object({
     project: projectIdSchema,
     name: frameNameSchema,
-    type: z.enum(["glts", "image", "market"]),
+    type: z.enum(["glts", "image", "markdown", "market"]),
     width: sizeSchema.optional(),
     height: sizeSchema.optional(),
     image: imageUrlSchema.optional(),
@@ -42,6 +42,7 @@ export const createFrameSchema = z
     };
     switch (input.type) {
         case "glts":
+        case "markdown":
             require("width");
             require("height");
             reject("image");
@@ -82,6 +83,18 @@ export function frameCreationInput(input) {
                 height: input.height,
                 ...position,
             };
+        case "markdown":
+            if (input.width === undefined || input.height === undefined) {
+                throw new Error("Validated Markdown frame input is missing dimensions");
+            }
+            return {
+                project: input.project,
+                name: input.name,
+                type: input.type,
+                width: input.width,
+                height: input.height,
+                ...position,
+            };
         case "image":
             if (input.image === undefined) {
                 throw new Error("Validated image frame input is missing an image");

package/dist/project-state.d.ts

@@ -32,6 +32,20 @@ export declare const projectGltsFrameRecordSchema: z.ZodObject<{
         }, z.core.$strict>;
     }, z.core.$strict>>;
 }, z.core.$strict>;
+export declare const projectMarkdownFrameRecordSchema: z.ZodObject<{
+    x: z.ZodNumber;
+    y: z.ZodNumber;
+    width: z.ZodNumber;
+    height: z.ZodNumber;
+    id: z.ZodString;
+    projectId: z.ZodString;
+    name: z.ZodString;
+    viewUrl: z.ZodString;
+    contentRevision: z.ZodNumber;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+    type: z.ZodLiteral<"markdown">;
+}, z.core.$strict>;
 export declare const projectImageFrameRecordSchema: z.ZodObject<{
     x: z.ZodNumber;
     y: z.ZodNumber;
@@ -132,6 +146,19 @@ export declare const projectFrameRecordSchema: z.ZodDiscriminatedUnion<[z.ZodObj
             w: z.ZodNumber;
         }, z.core.$strict>;
     }, z.core.$strict>>;
+}, z.core.$strict>, z.ZodObject<{
+    x: z.ZodNumber;
+    y: z.ZodNumber;
+    width: z.ZodNumber;
+    height: z.ZodNumber;
+    id: z.ZodString;
+    projectId: z.ZodString;
+    name: z.ZodString;
+    viewUrl: z.ZodString;
+    contentRevision: z.ZodNumber;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+    type: z.ZodLiteral<"markdown">;
 }, z.core.$strict>, z.ZodObject<{
     x: z.ZodNumber;
     y: z.ZodNumber;
@@ -201,7 +228,7 @@ export declare const projectFrameRecordSchema: z.ZodDiscriminatedUnion<[z.ZodObj
     }, z.core.$strict>;
 }, z.core.$strict>], "type">;
 export declare const projectStateSchema: z.ZodObject<{
-    schemaVersion: z.ZodLiteral<1>;
+    schemaVersion: z.ZodLiteral<2>;
     projectId: z.ZodString;
     revision: z.ZodNumber;
     frames: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
@@ -230,6 +257,19 @@ export declare const projectStateSchema: z.ZodObject<{
                 w: z.ZodNumber;
             }, z.core.$strict>;
         }, z.core.$strict>>;
+    }, z.core.$strict>, z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+        width: z.ZodNumber;
+        height: z.ZodNumber;
+        id: z.ZodString;
+        projectId: z.ZodString;
+        name: z.ZodString;
+        viewUrl: z.ZodString;
+        contentRevision: z.ZodNumber;
+        createdAt: z.ZodString;
+        updatedAt: z.ZodString;
+        type: z.ZodLiteral<"markdown">;
     }, z.core.$strict>, z.ZodObject<{
         x: z.ZodNumber;
         y: z.ZodNumber;
@@ -322,10 +362,15 @@ export declare const projectPresenceServerMessageSchema: z.ZodObject<{
         }, z.core.$strict>>;
     }, z.core.$strict>>;
 }, z.core.$strict>;
+export declare const projectCommentsChangedServerMessageSchema: z.ZodObject<{
+    type: z.ZodLiteral<"comments:changed">;
+}, z.core.$strict>;
 export type ProjectPresenceClientMessage = z.infer<typeof projectPresenceClientMessageSchema>;
 export type ProjectPresenceServerMessage = z.infer<typeof projectPresenceServerMessageSchema>;
+export type ProjectCommentsChangedServerMessage = z.infer<typeof projectCommentsChangedServerMessageSchema>;
 export type ProjectFrameLayout = z.infer<typeof projectFrameLayoutSchema>;
 export type ProjectGltsFrameRecord = z.infer<typeof projectGltsFrameRecordSchema>;
+export type ProjectMarkdownFrameRecord = z.infer<typeof projectMarkdownFrameRecordSchema>;
 export type ProjectImageFrameRecord = z.infer<typeof projectImageFrameRecordSchema>;
 export type ProjectMarketFile = z.infer<typeof projectMarketFileSchema>;
 export type ProjectMarketFrameRecord = z.infer<typeof projectMarketFrameRecordSchema>;

package/dist/project-state.js

@@ -36,6 +36,9 @@ export const projectGltsFrameRecordSchema = projectFrameRecordBaseSchema
     camera: cameraPoseSchema.optional(),
 })
     .strict();
+export const projectMarkdownFrameRecordSchema = projectFrameRecordBaseSchema
+    .extend({ type: z.literal("markdown") })
+    .strict();
 export const projectImageFrameRecordSchema = projectFrameRecordBaseSchema
     .extend({
     type: z.literal("image"),
@@ -70,12 +73,13 @@ export const projectMarketFrameRecordSchema = projectFrameRecordBaseSchema
     .strict();
 export const projectFrameRecordSchema = z.discriminatedUnion("type", [
     projectGltsFrameRecordSchema,
+    projectMarkdownFrameRecordSchema,
     projectImageFrameRecordSchema,
     projectMarketFrameRecordSchema,
 ]);
 export const projectStateSchema = z
     .object({
-    schemaVersion: z.literal(1),
+    schemaVersion: z.literal(2),
     projectId: designIdSchema,
     revision: z.number().int().nonnegative(),
     frames: z.array(projectFrameRecordSchema),
@@ -110,3 +114,6 @@ export const projectPresenceServerMessageSchema = z
     collaborators: z.array(projectCollaboratorSchema),
 })
     .strict();
+export const projectCommentsChangedServerMessageSchema = z
+    .object({ type: z.literal("comments:changed") })
+    .strict();

package/dist/protocol.d.ts

@@ -3,11 +3,58 @@ export declare const inspectionMessageTypes: {
     readonly applied: "drawcall:inspection:applied";
     readonly exit: "drawcall:inspection:exit";
     readonly failed: "drawcall:inspection:failed";
-    readonly focus: "drawcall:inspection:focus";
     readonly loading: "drawcall:inspection:loading";
     readonly ready: "drawcall:inspection:ready";
     readonly set: "drawcall:inspection:set";
 };
+export declare const previewMessageTypes: {
+    readonly configure: "drawcall:preview:configure";
+    readonly failed: "drawcall:preview:failed";
+    readonly fatal: "drawcall:preview:fatal";
+    readonly load: "drawcall:preview:load";
+    readonly loaded: "drawcall:preview:loaded";
+    readonly ready: "drawcall:preview:ready";
+};
+export declare const previewPixelRatioMax = 4;
+export declare const previewLoadCommandSchema: z.ZodObject<{
+    type: z.ZodLiteral<"drawcall:preview:load">;
+    requestId: z.ZodString;
+    frameId: z.ZodString;
+    camera: z.ZodNullable<z.ZodObject<{
+        position: z.ZodObject<{
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+            z: z.ZodNumber;
+        }, z.core.$strict>;
+        quaternion: z.ZodObject<{
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+            z: z.ZodNumber;
+            w: z.ZodNumber;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    pixelRatio: z.ZodNumber;
+}, z.core.$strict>;
+export declare const previewConfigureCommandSchema: z.ZodObject<{
+    type: z.ZodLiteral<"drawcall:preview:configure">;
+    pixelRatio: z.ZodNumber;
+}, z.core.$strict>;
+export declare const previewLoadResultSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    requestId: z.ZodString;
+    frameId: z.ZodString;
+    type: z.ZodLiteral<"drawcall:preview:loaded">;
+}, z.core.$strict>, z.ZodObject<{
+    requestId: z.ZodString;
+    frameId: z.ZodString;
+    type: z.ZodLiteral<"drawcall:preview:failed">;
+    error: z.ZodString;
+}, z.core.$strict>], "type">;
+export declare const previewSessionEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"drawcall:preview:ready">;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"drawcall:preview:fatal">;
+    error: z.ZodString;
+}, z.core.$strict>], "type">;
 export declare const immersiveMessageTypes: {
     readonly enter: "drawcall:immersive:enter";
     readonly error: "drawcall:immersive:error";
@@ -122,6 +169,116 @@ export declare const cameraMessageTypes: {
     readonly set: "drawcall:camera:set";
     readonly unavailable: "drawcall:camera:unavailable";
 };
+export declare const commentRuntimeMessageTypes: {
+    readonly action: "drawcall:comment:action";
+    readonly actionResult: "drawcall:comment:action-result";
+    readonly missed: "drawcall:comment:missed";
+    readonly pick: "drawcall:comment:pick";
+    readonly picked: "drawcall:comment:picked";
+    readonly selected: "drawcall:comment:selected";
+    readonly set: "drawcall:comments:set";
+};
+export declare const commentPickCommandSchema: z.ZodObject<{
+    type: z.ZodLiteral<"drawcall:comment:pick">;
+    requestId: z.ZodString;
+    x: z.ZodNumber;
+    y: z.ZodNumber;
+}, z.core.$strict>;
+export declare const commentPickResultSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"drawcall:comment:picked">;
+    requestId: z.ZodString;
+    position: z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+        z: z.ZodNumber;
+    }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"drawcall:comment:missed">;
+    requestId: z.ZodString;
+}, z.core.$strict>], "type">;
+export declare const commentStateCommandSchema: z.ZodObject<{
+    type: z.ZodLiteral<"drawcall:comments:set">;
+    activeComment: z.ZodNullable<z.ZodString>;
+    focusRequest: z.ZodNullable<z.ZodNumber>;
+    comments: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        projectId: z.ZodString;
+        frameId: z.ZodString;
+        body: z.ZodString;
+        author: z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+            image: z.ZodNullable<z.ZodString>;
+        }, z.core.$strict>;
+        replies: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            commentId: z.ZodString;
+            body: z.ZodString;
+            author: z.ZodObject<{
+                id: z.ZodString;
+                name: z.ZodString;
+                image: z.ZodNullable<z.ZodString>;
+            }, z.core.$strict>;
+            createdAt: z.ZodString;
+            updatedAt: z.ZodString;
+        }, z.core.$strict>>;
+        resolution: z.ZodOptional<z.ZodObject<{
+            resolvedAt: z.ZodString;
+            resolvedBy: z.ZodObject<{
+                id: z.ZodString;
+                name: z.ZodString;
+                image: z.ZodNullable<z.ZodString>;
+            }, z.core.$strict>;
+        }, z.core.$strict>>;
+        createdAt: z.ZodString;
+        updatedAt: z.ZodString;
+        position: z.ZodObject<{
+            kind: z.ZodLiteral<"3d">;
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+            z: z.ZodNumber;
+            frameContentRevision: z.ZodNumber;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    frameContentRevision: z.ZodNumber;
+    user: z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        image: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export declare const commentActionMessageSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"drawcall:comment:action">;
+    requestId: z.ZodString;
+    action: z.ZodLiteral<"reply">;
+    comment: z.ZodString;
+    body: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"drawcall:comment:action">;
+    requestId: z.ZodString;
+    action: z.ZodLiteral<"resolve">;
+    comment: z.ZodString;
+    resolved: z.ZodBoolean;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"drawcall:comment:action">;
+    requestId: z.ZodString;
+    action: z.ZodLiteral<"delete">;
+    target: z.ZodString;
+}, z.core.$strict>], "action">;
+export declare const commentActionResultSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"drawcall:comment:action-result">;
+    requestId: z.ZodString;
+    ok: z.ZodLiteral<true>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"drawcall:comment:action-result">;
+    requestId: z.ZodString;
+    ok: z.ZodLiteral<false>;
+    error: z.ZodString;
+}, z.core.$strict>], "ok">;
+export declare const commentSelectionMessageSchema: z.ZodObject<{
+    type: z.ZodLiteral<"drawcall:comment:selected">;
+    comment: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;
 export declare const sourceFileMessageTypes: {
     readonly changed: "drawcall:source-files:changed";
     readonly reloadResult: "drawcall:source-file:reload-result";
@@ -230,6 +387,12 @@ export declare const posterRenderResultSchema: z.ZodDiscriminatedUnion<[z.ZodObj
     type: z.ZodLiteral<"drawcall:poster:failed">;
     error: z.ZodString;
 }, z.core.$strict>], "type">;
+export declare const frameRenderResultSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    status: z.ZodLiteral<"rendered">;
+}, z.core.$strict>, z.ZodObject<{
+    status: z.ZodLiteral<"failed">;
+    error: z.ZodString;
+}, z.core.$strict>], "status">;
 export declare const inspectionCommandSchema: z.ZodObject<{
     type: z.ZodLiteral<"drawcall:inspection:set">;
     requestId: z.ZodString;
@@ -247,18 +410,25 @@ export declare const inspectionFrameMessageSchema: z.ZodDiscriminatedUnion<[z.Zo
     enabled: z.ZodBoolean;
 }, z.core.$strict>, z.ZodObject<{
     type: z.ZodLiteral<"drawcall:inspection:exit">;
-}, z.core.$strict>, z.ZodObject<{
-    type: z.ZodLiteral<"drawcall:inspection:focus">;
 }, z.core.$strict>], "type">;
 export type InspectionCommand = z.infer<typeof inspectionCommandSchema>;
+export type PreviewLoadCommand = z.infer<typeof previewLoadCommandSchema>;
+export type PreviewLoadResult = z.infer<typeof previewLoadResultSchema>;
 export type PosterRenderCommand = z.infer<typeof posterRenderCommandSchema>;
 export type PosterRenderResult = z.infer<typeof posterRenderResultSchema>;
+export type FrameRenderResult = z.infer<typeof frameRenderResultSchema>;
 export type ImmersiveMode = z.infer<typeof immersiveModeSchema>;
 export type ImmersiveCommand = z.infer<typeof immersiveCommandSchema>;
 export type ImmersiveFrameMessage = z.infer<typeof immersiveFrameMessageSchema>;
 export type CameraCaptureCommand = z.infer<typeof cameraCaptureCommandSchema>;
 export type CameraSetCommand = z.infer<typeof cameraSetCommandSchema>;
 export type CameraCaptureResult = z.infer<typeof cameraCaptureResultSchema>;
+export type CommentPickCommand = z.infer<typeof commentPickCommandSchema>;
+export type CommentPickResult = z.infer<typeof commentPickResultSchema>;
+export type CommentStateCommand = z.infer<typeof commentStateCommandSchema>;
+export type CommentActionMessage = z.infer<typeof commentActionMessageSchema>;
+export type CommentActionResult = z.infer<typeof commentActionResultSchema>;
+export type CommentSelectionMessage = z.infer<typeof commentSelectionMessageSchema>;
 export type SourceFileChange = z.infer<typeof sourceFileChangeSchema>;
 export type SourceFilesChangedMessage = z.infer<typeof sourceFilesChangedMessageSchema>;
 export type SourceFileReloadResult = z.infer<typeof sourceFileReloadResultSchema>;
@@ -279,4 +449,7 @@ export type GltsExportFrameMessage = z.infer<typeof gltsExportFrameMessageSchema
 /** The per-project page that renders frame posters; never a frame ID path. */
 export declare const posterPagePath = "/poster/";
 export declare function posterPageUrl(frameViewUrl: string): string;
+/** The per-project page that hosts the reusable live GLTS preview. */
+export declare const previewPagePath = "/preview/";
+export declare function previewPageUrl(frameViewUrl: string): string;
 export declare function projectSyncUrl(baseUrl: string, project: string): string;