dsh-image-gen 0.6.7 → 0.6.8

package/lib/types/client/tl/diagram-landing.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Land one create_diagram result onto a tldraw page.
+ *
+ * Shapes and their arrow bindings are created in a single editor.run
+ * transaction, and a history stopping point is marked BEFORE the batch:
+ * tldraw's HistoryManager pops diffs until the next stop mark on undo, so
+ * without the mark two diagrams landing back-to-back would undo together.
+ * With it, each diagram is one independent undo step (undo/redo verified
+ * against the HistoryManager source and on the real canvas).
+ *
+ * Arrows are ELBOW connectors with BOTH terminals bound. Each terminal's
+ * binding side is derived from dagre's polyline: the first/last segment's
+ * dominant axis says which node edge the route uses (back edges leave the
+ * source's top and re-enter the target's bottom through the corridor dagre
+ * reserved, instead of tldraw guessing a center-to-center route). tldraw
+ * then re-routes the middle segments itself from the bindings — the
+ * polyline is a per-terminal side hint, not a full path contract. Whether
+ * the final arrows avoid crossing nodes and whether labels sit clear of
+ * geometry is validated on the real canvas, not assumed here.
+ *
+ * Derived anchors are clamped to the middle band (0.2–0.8) of their edge:
+ * tldraw's getEdgeFromNormalizedAnchor resolves the side via |x-0.5| vs
+ * |y-0.5|, and a corner-ish anchor could resolve to the wrong side.
+ *
+ * Edge labels set labelPosition from dagre's arc-length ratio — a
+ * best-effort estimate, since tldraw applies the ratio to its own routed
+ * path.
+ *
+ * Self loops (empty dagre polyline) fall back to center bindings: tldraw
+ * draws bound self-loop arrows natively.
+ *
+ * Every created shape carries meta.diagramId, the same dedupe identity the
+ * landing reconcile uses for images' meta.galleryId.
+ */
+import { type Editor } from 'tldraw';
+import { type DiagramLayout, type DiagramLayoutEdge, type DiagramLayoutNode, type DiagramPoint } from './diagram-layout.js';
+import type { TlDiagramLanding } from './tl-canvas-bridge.js';
+/** Terminal binding plan: the precise anchor, or a center fallback. */
+export interface TerminalPlan {
+    anchor: {
+        x: number;
+        y: number;
+    };
+    precise: boolean;
+}
+/**
+ * Derive one terminal's binding side + precise anchor from dagre's
+ * polyline. The boundary point sits ON the node outline (dagre guarantees
+ * this via its node-intersection pass), so the binding side is the OUTLINE
+ * EDGE CLOSEST TO THE BOUNDARY POINT — not the segment direction. The last
+ * segment often enters at an angle because dagre projects the corridor
+ * point onto the outline (e.g. a back edge entering the target's bottom
+ * with a final dx=57, dy=-48 segment), and direction-dominance would
+ * misread that as `right`. The segment direction is only used to break
+ * exact corner ties. The boundary point gives the cross-axis position,
+ * clamped to the anchor band.
+ */
+export declare function terminalPlan(node: Pick<DiagramLayoutNode, 'x' | 'y' | 'w' | 'h'>, boundary: DiagramPoint, next: DiagramPoint): TerminalPlan;
+/**
+ * Binding plans for one edge's two terminals. Self loops (no dagre
+ * polyline) get center plans: tldraw renders bound self loops natively.
+ */
+export declare function edgeTerminalPlans(edge: DiagramLayoutEdge, fromNode: DiagramLayoutNode, toNode: DiagramLayoutNode): {
+    start: TerminalPlan;
+    end: TerminalPlan;
+};
+/**
+ * Land one diagram with its top-left at `origin`. The caller passes the
+ * precomputed layout (it needs the layout bounds to pick the origin, so the
+ * layout is computed once and shared). No-op on empty layouts.
+ */
+export declare function landDiagram(editor: Editor, landing: TlDiagramLanding, layout: DiagramLayout, origin: {
+    x: number;
+    y: number;
+}): void;

package/lib/types/client/tl/diagram-layout.d.ts

@@ -0,0 +1,76 @@
+import type { DiagramNodeShape, DiagramSpec } from '../../shared.js';
+/** One laid-out node: local id, label, outline, top-left position, size. */
+export interface DiagramLayoutNode {
+    id: string;
+    label: string;
+    shape: DiagramNodeShape;
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+}
+/** A point in graph space (same origin as the layout nodes). */
+export interface DiagramPoint {
+    x: number;
+    y: number;
+}
+/** One laid-out edge between node local ids, with dagre's routing hint. */
+export interface DiagramLayoutEdge {
+    from: string;
+    to: string;
+    label?: string;
+    /**
+     * dagre's polyline in graph space. points[0] lies on the source node's
+     * outline and points[last] on the target's. Self loops carry an empty
+     * array: dagre cannot route them, and the landing layer falls back to
+     * center bindings (tldraw draws bound self loops natively).
+     */
+    points: DiagramPoint[];
+    /**
+     * Where the label sits along the polyline, as an arc-length ratio in
+     * [0, 1] (tldraw's arrow labelPosition shares the ratio semantics). This
+     * is a best-effort initial estimate: tldraw applies the ratio to its own
+     * routed path, which may differ from dagre's polyline in the middle
+     * segments. The final label position is validated on the real canvas.
+     */
+    labelPosition?: number;
+}
+export interface DiagramLayout {
+    nodes: DiagramLayoutNode[];
+    edges: DiagramLayoutEdge[];
+    width: number;
+    height: number;
+    /** Growth direction of the layout, needed by the landing layer to pick
+     * binding anchors (TB connects bottom→top edges, LR right→left edges). */
+    direction: 'TB' | 'LR';
+}
+/** Node size in canvas units (top-left anchored, like tldraw shape props). */
+export interface DiagramSize {
+    w: number;
+    h: number;
+}
+/** Measured sizes fed into the pure layout function. */
+export interface DiagramMeasurements {
+    /** node id → measured node size. Missing entries fall back to the default. */
+    nodes: ReadonlyMap<string, DiagramSize>;
+    /**
+     * edge list index → measured label size. Only edges carrying a label are
+     * present; dagre reserves rank space for these labels.
+     */
+    edgeLabels?: ReadonlyMap<number, DiagramSize>;
+}
+/** Fallback size for nodes the caller did not measure (defensive only). */
+export declare const DEFAULT_NODE_SIZE: DiagramSize;
+/**
+ * Where a point sits along a polyline, as an arc-length ratio in [0, 1].
+ * The point is projected onto the nearest polyline segment. Degenerate
+ * polylines return 0.5.
+ */
+export declare function arcRatioAlongPolyline(points: readonly DiagramPoint[], target: DiagramPoint): number;
+/**
+ * Lay out a diagram spec with coordinates relative to (0, 0). The layout is
+ * deterministic: same spec + same measurements always produce the same
+ * coordinates (dagre is seeded by insertion order, which we keep stable by
+ * iterating the spec's arrays as given).
+ */
+export declare function layoutDiagram(diagram: DiagramSpec, measurements: DiagramMeasurements): DiagramLayout;

package/lib/types/client/tl/diagram-measure.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Measure diagram node/edge-label sizes with tldraw's own DOM text measuring.
+ *
+ * This is the "real" half of the measurement/layout split: the editor's
+ * TextManager renders text with the same font family, size, line height and
+ * wrap width the landed geo shapes will use, so RECTANGLE node sizes track
+ * the rendered label 1:1 (no character-width heuristics).
+ *
+ * The measure parameters mirror tldraw's internal geo-shape constants for
+ * our landed shapes (font 'sans', size 'm'): theme.fontSize * 1.375,
+ * theme.lineHeight, label padding 16.
+ *
+ * Non-rectangular outlines are APPROXIMATE, not 1:1. tldraw re-wraps the
+ * label against the SHAPE's width (shape w - padding), and we size the
+ * shape from the text measured at the pre-inflation wrap width — so after
+ * inflation the label re-wraps into fewer, wider lines. For short labels
+ * (single line at the wrap width) the geometry below is exact. For long
+ * wrapped labels the re-wrapped block can grow past the outline's inscribed
+ * rectangle and crowd the diamond's slanted edges / the ellipse's arc:
+ * greedy text wrapping scales with shape width while the inscribed rectangle
+ * only halves it, so there is no closed-form fix. The create_diagram tool
+ * prompt steers long text to rectangles and keeps diamond labels short;
+ * whether a real label fits is ultimately a visual check on the real canvas
+ * (see the diagram-verify harness), not something this module can promise.
+ *   - diamond: a single-line text rect (tw, th) fits exactly when
+ *     tw/w + th/h <= 1, so doubling the text size (+ padding) is exact for
+ *     unwrapped labels.
+ *   - ellipse: a single-line corner point fits exactly when
+ *     tw²/w² + th²/h² <= 1, so a √2 factor (+ padding) is exact for
+ *     unwrapped labels.
+ */
+import type { Editor } from 'tldraw';
+import type { DiagramSpec } from '../../shared.js';
+import type { DiagramMeasurements } from './diagram-layout.js';
+/**
+ * Measure every node and edge label of a spec against the editor's live
+ * theme and fonts. Node sizes carry the outline inflation for diamond and
+ * ellipse; edge-label sizes let dagre reserve rank space for labels.
+ */
+export declare function measureDiagram(editor: Editor, diagram: DiagramSpec): DiagramMeasurements;

package/lib/types/diagram.d.ts

@@ -0,0 +1,42 @@
+/**
+ * create_diagram: a structure-only tool whose results land on the workbench
+ * infinite canvas.
+ *
+ * The model outputs a declarative DSL (nodes + edges with local ids, never
+ * coordinates). The tool call succeeds immediately — exactly like image
+ * generation — and the diagram rides the same landing bus: an open canvas
+ * renders it at once, a closed one renders it the moment it opens. The canvas
+ * computes the layered layout, creates geo shapes, and binds every arrow to
+ * its endpoints so the user can drag nodes around with arrows following.
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import { type DiagramDirection, type DiagramEdgeSpec, type DiagramNodeSpec } from './shared.js';
+/** Value returned by create_diagram and echoed into the tool-result schema. */
+export interface CreateDiagramValue {
+    diagramId: string;
+    title: string;
+    direction: DiagramDirection;
+    nodeCount: number;
+    edgeCount: number;
+}
+/** Untrusted create_diagram arguments as they arrive from the model. */
+export interface CreateDiagramArgs {
+    title?: unknown;
+    direction?: unknown;
+    nodes?: unknown;
+    edges?: unknown;
+}
+/** Register the create_diagram tool on a host context. */
+export declare function registerDiagramTool(ctx: Context): void;
+/**
+ * Validate untrusted create_diagram arguments into a DiagramSpec. Returns
+ * undefined for anything structurally unusable (no nodes, duplicate ids,
+ * edges pointing at unknown nodes, over the caps) — the tool then fails with
+ * an actionable message and the model can retry with a corrected diagram.
+ */
+export declare function diagramSpecFromArgs(args: CreateDiagramArgs): {
+    title?: string;
+    direction?: DiagramDirection;
+    nodes: DiagramNodeSpec[];
+    edges: DiagramEdgeSpec[];
+} | undefined;

package/lib/types/shared.d.ts

@@ -117,6 +117,18 @@ export declare function isSubscriptionProvider(provider: ImageProvider): provide
 /** Providers supported by the first browser workbench release. */
 export declare const CLOUD_IMAGE_PROVIDERS: readonly ["google", "openai", "openai-compat", "seedream", "dashscope", "xai", "zhipu"];
 export type CloudImageProvider = typeof CLOUD_IMAGE_PROVIDERS[number];
+/**
+ * Providers the browser workbench can drive: the BYOK cloud set plus the
+ * logged-in subscription channels. ComfyUI stays out; it has its own workflow
+ * pipeline and no shared request shape.
+ */
+export declare const STUDIO_PROVIDERS: readonly ["google", "openai", "openai-compat", "seedream", "dashscope", "xai", "zhipu", "chatgpt-sub", "grok-sub", "google-sub"];
+export type StudioProvider = CloudImageProvider | SubscriptionProvider;
+/** True when the provider is selectable in the browser workbench. */
+export declare function isStudioProvider(provider: ImageProvider): provider is StudioProvider;
+/** Timeout for one subscription image call, shared by the tool path and the
+ * studio route so neither drifts from the other. */
+export declare const SUBSCRIPTION_TIMEOUT_MS = 300000;
 /**
  * Credential references resolved through the DSH Credentials service (BYOK).
  * These are POSIX-style reference names, not environment variables: the host
@@ -155,7 +167,7 @@ export interface StudioOption {
 }
 /** Browser-safe provider description. Credentials and endpoints never cross this boundary. */
 export interface StudioProviderProfile {
-    provider: CloudImageProvider;
+    provider: StudioProvider;
     label: string;
     model: string;
     configured: boolean;
@@ -175,7 +187,7 @@ export interface StudioWorkspaceInfo {
 /** Read model and capability state for the workbench without exposing secrets. */
 export interface StudioConfigResponse {
     providers: StudioProviderProfile[];
-    activeProvider: CloudImageProvider;
+    activeProvider: StudioProvider;
     workspaceRoot?: string | undefined;
     workspaces?: StudioWorkspaceInfo[] | undefined;
 }
@@ -193,7 +205,7 @@ export type StudioReference = StudioEncodedReference | StudioAttachmentReference
 /** One browser workbench generation or editing request. */
 export interface StudioGenerateRequest {
     mode: 'generate' | 'edit';
-    provider: CloudImageProvider;
+    provider: StudioProvider;
     model: string;
     prompt: string;
     ratio: string;
@@ -211,7 +223,7 @@ export interface StudioGeneratedItem {
 }
 /** One completed workbench request. */
 export interface StudioGenerateResponse extends StudioGeneratedItem {
-    provider: CloudImageProvider;
+    provider: StudioProvider;
     model: string;
     prompt: string;
     createdAt: number;

package/lib/types/studio-chat.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Dedicated DSH agent session backing the workbench chat panel.
+ *
+ * The panel is a real DSH conversation driven from the plugin, not a parallel
+ * chat implementation: on first use the host creates an agent through
+ * ctx.agents.create (the same factory the sidebar uses), then archives the
+ * session through ctx.workspaceRegistry so it never appears in the sidebar
+ * history list while remaining fully usable. The plugin never calls
+ * sessions.open - archiving the selected session would clear the user's
+ * current selection - and drives turns purely through agent.followup().
+ *
+ * Session events are projected into a small lossless-enough StudioChatEvent
+ * feed (text turns, tool summaries, generated-image references) and served to
+ * the browser through CHAT_ROUTE. The browser pulls increments with
+ * ?since=<seq>; images land on the tldraw canvas from the browser side via
+ * the existing IMAGE_ROUTE + landing-queue path.
+ */
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import type { Context } from '@deepseek-ai/cordis';
+import { type StudioChatEvent } from './shared.js';
+/** Wire responses for CHAT_ROUTE. */
+export interface StudioChatStateResponse {
+    ok: true;
+    latestSeq: number;
+    events: StudioChatEvent[];
+    /** Why the backing agent is missing, when creation failed; absent otherwise. */
+    unavailable?: string;
+}
+export interface StudioChatSendResponse {
+    ok: true;
+}
+export interface StudioChatErrorResponse {
+    error: string;
+}
+export interface StudioChatDeps {
+    maxBodyBytes: number;
+}
+/**
+ * Install the studio chat: ensure the dedicated agent session, subscribe to
+ * its events, and return the CHAT_ROUTE handler plus a disposer. Creation
+ * failures never break the plugin load - the route reports the error and the
+ * panel shows it, so a host without agent services degrades visibly instead
+ * of fatally.
+ */
+export declare function createStudioChat(ctx: Context, deps: StudioChatDeps): {
+    serve: (req: IncomingMessage, res: ServerResponse) => Promise<void>;
+    dispose(): void;
+};

package/lib/types/studio.d.ts

@@ -1,9 +1,10 @@
 import type { Context } from '@deepseek-ai/cordis';
 import { type Config } from './config.js';
+import { type SubscriptionManager } from './subscription.js';
 import { type CloudImageProvider, type StudioConfigResponse, type StudioGenerateRequest, type StudioGenerateResponse, type StudioProviderProfile } from './shared.js';
 /** Return only browser-safe capability data. */
-export declare function describeStudio(ctx: Context, config: Config): Promise<StudioConfigResponse>;
+export declare function describeStudio(ctx: Context, config: Config, subscriptions?: SubscriptionManager | undefined): Promise<StudioConfigResponse>;
 /** Execute one validated browser workbench request using the existing provider adapters. */
-export declare function generateFromStudio(ctx: Context, config: Config, input: StudioGenerateRequest, signal: AbortSignal, fallbackWorkspaceRoot?: string | undefined): Promise<StudioGenerateResponse>;
+export declare function generateFromStudio(ctx: Context, config: Config, input: StudioGenerateRequest, signal: AbortSignal, fallbackWorkspaceRoot?: string | undefined, subscriptions?: SubscriptionManager | undefined): Promise<StudioGenerateResponse>;
 export declare function runPool<T>(tasks: Array<() => Promise<T>>, concurrency?: number): Promise<PromiseSettledResult<T>[]>;
 export declare function studioProfile(config: Config, provider: CloudImageProvider, configured: boolean): StudioProviderProfile;

package/lib/types/subscription/manager.d.ts

@@ -21,12 +21,26 @@ import { type SubscriptionBlob } from './blob.js';
 import { type SubscriptionProvider } from '../shared.js';
 /** Vendor ids used by the credential refs and the wire calls. */
 export type SubscriptionVendor = 'codex' | 'grok' | 'antigravity';
+/**
+ * Reference image passed to edit calls. Structural so callers can pass their
+ * own resolved types without importing from the plugin root.
+ */
+export interface SubscriptionReferenceImage {
+    data: Uint8Array;
+    mediaType: string;
+}
 /** The vendor each dsh-image-gen subscription provider maps onto. */
 export declare function vendorOf(provider: SubscriptionProvider): SubscriptionVendor;
 /** Credential ref one vendor's OAuth blob is stored under (index fixed at 1). */
 export declare function subscriptionOauthRef(vendor: SubscriptionVendor): CredentialRef;
 /** Sizes both vendors understand. */
 export declare const SUBSCRIPTION_SIZES: readonly ["1024x1024", "1024x1536", "1536x1024", "auto"];
+/**
+ * Reference images per edit call. Every subscription channel accepts at
+ * least this many (Codex edits up to 16, Grok up to 5, Antigravity up to 10),
+ * so 5 keeps one shared guard in line with the Studio UI's upload cap.
+ */
+export declare const SUBSCRIPTION_MAX_REFERENCE_IMAGES = 5;
 /** Login status the settings card renders as a badge. */
 export type SubscriptionLoginStatus = {
     state: 'logged-in';
@@ -80,6 +94,7 @@ export declare class SubscriptionManager {
         prompt: string;
         size?: string;
         quality?: string;
+        referenceImages?: ReadonlyArray<SubscriptionReferenceImage>;
         signal?: AbortSignal;
     }): Promise<Array<{
         b64_json: string;

package/lib/types/subscription/vendors/antigravity.d.ts

@@ -37,12 +37,17 @@ export declare function antigravityResolveProject(blob: SubscriptionBlob): Promi
  * Build the streamGenerateContent request body for one image generation.
  * Ported from the reference buildImageRequest + the wrapping envelope: no
  * tools, no systemInstruction, no thinkingConfig; responseModalities asks
- * for TEXT+IMAGE.
+ * for TEXT+IMAGE. Reference images (edits) ride along as inlineData parts
+ * before the text part, mirroring the reference implementation.
  */
 export declare function antigravityImageBody(options: {
     prompt: string;
     aspectRatio?: string;
     hd?: boolean;
+    referenceImages?: ReadonlyArray<{
+        data: Uint8Array;
+        mediaType: string;
+    }>;
 }): Record<string, unknown>;
 /** Wrap the inner request in the Antigravity agent envelope. */
 export declare function antigravityEnvelope(projectId: string, request: Record<string, unknown>): Record<string, unknown>;
@@ -62,5 +67,9 @@ export declare function antigravityGenerateImage(options: {
     prompt: string;
     aspectRatio?: string;
     hd?: boolean;
+    referenceImages?: ReadonlyArray<{
+        data: Uint8Array;
+        mediaType: string;
+    }>;
     signal?: AbortSignal;
 }): Promise<AntigravityImageResult>;

package/lib/types/subscription/vendors/codex.d.ts

@@ -12,6 +12,8 @@ export declare const CODEX_AUTH = "https://auth.openai.com/oauth/authorize";
 export declare const CODEX_TOKEN = "https://auth.openai.com/oauth/token";
 /** Where the ChatGPT subscription image request goes. */
 export declare const CODEX_IMAGE_URL = "https://chatgpt.com/backend-api/codex/images/generations";
+/** Where the ChatGPT subscription image edit request goes. */
+export declare const CODEX_IMAGE_EDIT_URL = "https://chatgpt.com/backend-api/codex/images/edits";
 /** The model served by this endpoint (probed live: gpt-image-2.5-flare works
  * on the ChatGPT internal generations route as of 2026-09-14). */
 export declare const CODEX_IMAGE_MODEL = "gpt-image-2.5-flare";

package/lib/types/subscription/vendors/grok.d.ts

@@ -10,6 +10,8 @@ import { type Pkce } from '../oauth.js';
 import type { SubscriptionBlob } from '../blob.js';
 /** Where the Grok subscription image request goes. */
 export declare const GROK_IMAGE_URL = "https://api.x.ai/v1/images/generations";
+/** Where the Grok subscription image edit request goes. */
+export declare const GROK_IMAGE_EDIT_URL = "https://api.x.ai/v1/images/edits";
 /** The model served by this endpoint. */
 export declare const GROK_IMAGE_MODEL = "grok-imagine-image-2.0";
 /** Public client id of the grok-cli; vendor-fixed redirect on 127.0.0.1:56121. */

package/lib/types/subscription.d.ts

@@ -18,12 +18,12 @@ import { SubscriptionManager } from './subscription/manager.js';
 import { type SubscriptionProvider } from './shared.js';
 export { SubscriptionManager, vendorOf } from './subscription/manager.js';
 export { registerSubscriptionRoutes } from './subscription/subscription-route.js';
-/** Timeout for one subscription image call, mirroring the other adapters. */
-export declare const SUBSCRIPTION_TIMEOUT_MS = 300000;
+export { SUBSCRIPTION_TIMEOUT_MS } from './shared.js';
 /**
  * Generate one image through a logged-in subscription account. Returns the
  * same `{ data, mediaType }` contract as the API-key adapters so the caller
- * can feed it straight into `saveGenerated`.
+ * can feed it straight into `saveGenerated`. With sourceImages the call is
+ * an edit: the vendor layer picks the channel's edit endpoint.
  */
 export declare function generateSubscriptionImage(options: {
     manager: SubscriptionManager;
@@ -31,6 +31,10 @@ export declare function generateSubscriptionImage(options: {
     prompt: string;
     size?: string;
     quality?: string;
+    sourceImages?: ReadonlyArray<{
+        data: Uint8Array;
+        mediaType: ImageMediaType;
+    }>;
     maxBytes: number;
     signal: AbortSignal;
 }): Promise<{
@@ -38,5 +42,3 @@ export declare function generateSubscriptionImage(options: {
     mediaType: ImageMediaType;
     revisedPrompt?: string;
 }>;
-/** Subscription channels are prompt-only today; edit_image is rejected outright. */
-export declare function assertSubscriptionEditUnsupported(provider: SubscriptionProvider): never;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-image-gen",
-  "version": "0.6.7",
+  "version": "0.6.8",
   "description": "Bring ChatGPT-like image generation to DeepSeek Harness — Gemini, OpenAI, Seedream, DashScope, local ComfyUI & more.",
   "type": "module",
   "author": "shanliuling",
@@ -56,6 +56,13 @@
       "platform": "web"
     }
   },
+  "scripts": {
+    "typecheck": "tsc --noEmit",
+    "build": "tsc && tsdown",
+    "prepare": "pnpm run build",
+    "test": "vitest run",
+    "pack:check": "pnpm pack --dry-run"
+  },
   "engines": {
     "node": "^22.19.0 || >=24.0.0"
   },
@@ -127,14 +134,9 @@
     "unrun": "^0.3.1",
     "vitest": "^4.1.8"
   },
+  "packageManager": "pnpm@11.7.0",
   "dependencies": {
     "lucide-react": "^1.38.0",
     "tldraw": "5.3.0"
-  },
-  "scripts": {
-    "typecheck": "tsc --noEmit",
-    "build": "tsc && tsdown",
-    "test": "vitest run",
-    "pack:check": "pnpm pack --dry-run"
   }
-}
+}

package/skills/install-dsh-image-gen/SKILL.md

@@ -1,22 +1,22 @@
----
-name: install-dsh-image-gen
-description: Install, configure, verify, or remove the dsh-image-gen Bundle in a DeepSeek Harness Web profile. Use when a user wants Google, OpenAI-compatible relay, Seedream, DashScope, or local ComfyUI image generation in DSH, cannot find the Image generation settings card, or needs help testing generate_image.
----
-
-# Install DSH Image Gen
-
-1. Confirm `dsh` runs and record `dsh --version`.
-2. Ask which Web profile to change if the user did not name one. Default to `web` only when that profile already exists.
-3. Install the pinned package or repository spec the user provides:
-
-   ```sh
-   dsh plugin --profile <profile> add <package-or-git-spec>
-   ```
-
-4. If pnpm blocks the Git dependency's `prepare` script, explain that the allowance executes repository code during installation. Add only the exact package key pnpm reports to the profile's `pnpm-workspace.yaml`, then retry after the user approves.
-5. Verify `dsh --profile <profile> --dump-config` contains the `dsh-image-gen` layer and `image-gen` row.
-6. Start the profile. If port 3080 is already in use, identify the existing DSH process before stopping anything.
-7. In Settings > Plugins > Plugin configuration > Image generation, select a cloud Provider and save its API key, or select Local ComfyUI, enter its URL, and import a ComfyUI API Format workflow JSON containing `{{prompt}}`. Never print, read back, or commit a key.
-8. Test with “生成一张戴墨镜的赛博朋克猫图片”. Confirm one `generate_image` call succeeds and its image renders in the conversation.
-
-For removal, run `dsh plugin --profile <profile> remove dsh-image-gen`. Do not delete the user's credentials unless they explicitly request it.
+---
+name: install-dsh-image-gen
+description: Install, configure, verify, or remove the dsh-image-gen Bundle in a DeepSeek Harness Web profile. Use when a user wants Google, OpenAI-compatible relay, Seedream, DashScope, or local ComfyUI image generation in DSH, cannot find the Image generation settings card, or needs help testing generate_image.
+---
+
+# Install DSH Image Gen
+
+1. Confirm `dsh` runs and record `dsh --version`.
+2. Ask which Web profile to change if the user did not name one. Default to `web` only when that profile already exists.
+3. Install the pinned package or repository spec the user provides:
+
+   ```sh
+   dsh plugin --profile <profile> add <package-or-git-spec>
+   ```
+
+4. If pnpm blocks the Git dependency's `prepare` script, explain that the allowance executes repository code during installation. Add only the exact package key pnpm reports to the profile's `pnpm-workspace.yaml`, then retry after the user approves.
+5. Verify `dsh --profile <profile> --dump-config` contains the `dsh-image-gen` layer and `image-gen` row.
+6. Start the profile. If port 3080 is already in use, identify the existing DSH process before stopping anything.
+7. In Settings > Plugins > Plugin configuration > Image generation, select a cloud Provider and save its API key, or select Local ComfyUI, enter its URL, and import a ComfyUI API Format workflow JSON containing `{{prompt}}`. Never print, read back, or commit a key.
+8. Test with “生成一张戴墨镜的赛博朋克猫图片”. Confirm one `generate_image` call succeeds and its image renders in the conversation.
+
+For removal, run `dsh plugin --profile <profile> remove dsh-image-gen`. Do not delete the user's credentials unless they explicitly request it.

package/lib/types/client/inspiration-api.d.ts

@@ -1,10 +0,0 @@
-import type { InspirationCasesResponse } from '../inspiration/types.js';
-export declare function getInspirationImageUrl(sourceId: string, caseId: string): string;
-export declare function fetchInspirationCases(): Promise<InspirationCasesResponse | null>;
-export interface UpdateResponse {
-    updated: boolean;
-    currentCount: number;
-    newCount?: number;
-    message: string;
-}
-export declare function triggerInspirationUpdate(): Promise<UpdateResponse | null>;

package/lib/types/client/inspiration-detail.d.ts

@@ -1,14 +0,0 @@
-/**
- * Modal detail view for a specific Inspiration Library case.
- */
-import { type FC } from 'react';
-import type { PromptCase, PromptSource } from '../inspiration/types.js';
-export interface InspirationDetailProps {
-    promptCase: PromptCase;
-    source: PromptSource;
-    lang?: 'zh' | 'en';
-    onClose: () => void;
-    onUsePrompt: (prompt: string) => void;
-    onToast: (msg: string) => void;
-}
-export declare const InspirationDetail: FC<InspirationDetailProps>;

package/lib/types/client/tldraw/generated/tldraw-assets.d.ts

@@ -1,12 +0,0 @@
-export declare const TLDRAW_ASSET_URLS: {
-    fonts: Record<string, string>;
-    icons: Record<string, string>;
-    translations: Record<string, string>;
-};
-export declare const TLDRAW_ASSETS_META: {
-    version: string;
-    fonts: number;
-    icons: number;
-    translations: number;
-    generatedAt: string;
-};