@luv1211/dsh-pet 0.1.1-rc.2

package/lib/types/runtime.js

@@ -0,0 +1,314 @@
+/** Browser-safe pet constants, validation, presentation selection, and timing. */
+import { DEFAULT_PET_ANIMATIONS, parsePetPackage } from '@luv1211/dsh-pet-compat';
+import { imageDimensionsFromData } from 'image-dimensions';
+/** Version of the durable pet preference document. */
+export const PET_PREFERENCE_VERSION = 3;
+/** Built-in identifier selected by a fresh preference document. */
+export const DEFAULT_PET_ID = 'deepseek-whale';
+/** Default logical CSS height of one compatible atlas cell. */
+export const DEFAULT_PET_SIZE_PX = 112;
+/** Minimum logical CSS height accepted by the pet preference validator. */
+export const MIN_PET_SIZE_PX = 80;
+/** Maximum logical CSS height accepted by the pet preference validator. */
+export const MAX_PET_SIZE_PX = 224;
+/** Compatible atlas geometry owned by the DSH renderer. */
+export const PET_COMPAT_ATLAS = Object.freeze({
+    width: 1536,
+    height: 1872,
+    cellWidth: 192,
+    cellHeight: 208,
+    columns: 8,
+    rows: 9,
+});
+/** Stable validation error that callers can diagnose without parsing messages. */
+export class PetValidationError extends TypeError {
+    /** Machine-readable validation category. */
+    code = 'invalid-pet-package';
+    constructor(message) {
+        super(message);
+        this.name = 'PetValidationError';
+    }
+}
+/** Numeric status precedence, where lower values are selected first. */
+const ACTIVITY_PRIORITY = {
+    'needs-input': 0,
+    blocked: 1,
+    ready: 2,
+    running: 3,
+};
+/**
+ * Sort activity records by user-action urgency, then newest state transition,
+ * then their stable opaque session ids.
+ * @param left - the first activity record.
+ * @param right - the second activity record.
+ * @returns a standard ascending sort comparison result.
+ */
+export function comparePetActivities(left, right) {
+    const priority = ACTIVITY_PRIORITY[left.status] - ACTIVITY_PRIORITY[right.status];
+    if (priority !== 0)
+        return priority;
+    if (left.since !== right.since)
+        return right.since - left.since;
+    return left.sessionId < right.sessionId ? -1 : left.sessionId > right.sessionId ? 1 : 0;
+}
+/** Resolve a missing preference or validate a current preference document.
+ * @param value - decoded preference value from the settings provider.
+ * @returns the validated v3 preference.
+ */
+export function resolvePetPreference(value) {
+    if (value === undefined || value === null)
+        return defaultPetPreference();
+    if (!isRecord(value) || typeof value.version !== 'number')
+        throw new TypeError('pet preference must be an object with a numeric version');
+    if (value.version !== PET_PREFERENCE_VERSION) {
+        throw new TypeError(`pet preference version ${String(value.version)} is unsupported (expected ${PET_PREFERENCE_VERSION})`);
+    }
+    return {
+        version: PET_PREFERENCE_VERSION,
+        selectedPetId: requirePetId(value.selectedPetId),
+        awake: requireBoolean(value.awake, 'awake'),
+        sizePx: validatePetSize(value.sizePx),
+    };
+}
+/** Return the fresh v3 preference defaults.
+ * @returns a new v3 preference document.
+ */
+export function defaultPetPreference() {
+    return { version: PET_PREFERENCE_VERSION, selectedPetId: DEFAULT_PET_ID, awake: true, sizePx: DEFAULT_PET_SIZE_PX };
+}
+/** Validate one logical CSS height.
+ * @param sizePx - candidate logical CSS height.
+ * @returns the validated height.
+ */
+export function validatePetSize(sizePx) {
+    if (typeof sizePx !== 'number' || !Number.isSafeInteger(sizePx) || sizePx < MIN_PET_SIZE_PX || sizePx > MAX_PET_SIZE_PX) {
+        throw new TypeError(`pet preference sizePx must be between ${MIN_PET_SIZE_PX} and ${MAX_PET_SIZE_PX}`);
+    }
+    return sizePx;
+}
+/** Return true only after pointer movement exceeds the shared four-pixel drag threshold.
+ * @param deltaX - horizontal pointer displacement.
+ * @param deltaY - vertical pointer displacement.
+ * @param threshold - minimum Euclidean displacement.
+ * @returns whether the displacement is a drag.
+ */
+export function isDragMovement(deltaX, deltaY, threshold = 4) {
+    return Number.isFinite(deltaX) && Number.isFinite(deltaY) && Number.isFinite(threshold)
+        && threshold >= 0 && Math.hypot(deltaX, deltaY) > threshold;
+}
+/** Derive the logical CSS width from one validated atlas-cell height.
+ * @param sizePx - validated logical CSS height.
+ * @returns the corresponding logical CSS width.
+ */
+export function petWidthForSize(sizePx) {
+    return Math.round(validatePetSize(sizePx) * PET_COMPAT_ATLAS.cellWidth / PET_COMPAT_ATLAS.cellHeight);
+}
+/** Pick one of sixteen clockwise look-direction cells from a relative target.
+ * @param target - relative pointer target, or `undefined` for neutral direction.
+ * @returns a direction index from zero through fifteen.
+ */
+export function selectLookDirection(target) {
+    if (target === undefined || !Number.isFinite(target.x) || !Number.isFinite(target.y))
+        return 0;
+    if (Math.abs(target.x) <= 1 && Math.abs(target.y) <= 1)
+        return 0;
+    const angle = Math.atan2(target.x, -target.y);
+    const normalized = angle < 0 ? angle + Math.PI * 2 : angle;
+    return Math.floor((normalized + Math.PI / 16) / (Math.PI / 8)) % 16;
+}
+/** Select the state and first frame used to render one presentation update.
+ * @param input - current host, pointer, motion, and wake state.
+ * @returns the renderer-independent presentation selection.
+ */
+export function selectPetPresentation(input) {
+    const lookDirection = selectLookDirection(input.lookTarget);
+    if (!input.awake)
+        return { state: 'tucked', row: 0, frame: 0, lookDirection, lookDirectionActive: false, animate: false };
+    let state = statusToAnimationState(input.status);
+    if (input.hover)
+        state = 'jumping';
+    else if (input.status === 'running' && input.dragDirection === 'left')
+        state = 'running-left';
+    else if (input.status === 'running' && input.dragDirection === 'right')
+        state = 'running-right';
+    const spriteIndex = DEFAULT_PET_ANIMATIONS[state]?.frames[0]?.spriteIndex ?? 0;
+    return {
+        state,
+        row: Math.floor(spriteIndex / PET_COMPAT_ATLAS.columns),
+        frame: spriteIndex % PET_COMPAT_ATLAS.columns,
+        lookDirection,
+        lookDirectionActive: false,
+        animate: !input.reducedMotion,
+    };
+}
+/** Validate a compatible manifest and its WebP dimensions without Node or filesystem APIs.
+ * @param manifestBytes - UTF-8 pet.json bytes.
+ * @param spritesheetBytes - WebP atlas bytes.
+ * @param options - catalog origin, optional asset URL, and byte limits.
+ * @returns a sanitized descriptor suitable for client transport.
+ */
+export function validatePetPackage(manifestBytes, spritesheetBytes, options) {
+    return validatePetPackageFiles(manifestBytes, spritesheetBytes, options).descriptor;
+}
+/** Validate package bytes and retain the manifest-relative asset location for host storage.
+ * @param manifestBytes - UTF-8 pet.json bytes.
+ * @param spritesheetBytes - WebP atlas bytes.
+ * @param options - catalog origin, optional asset URL, and byte limits.
+ * @returns sanitized client metadata and the validated relative spritesheet path.
+ */
+export function validatePetPackageFiles(manifestBytes, spritesheetBytes, options) {
+    const maxManifestBytes = options.maxManifestBytes ?? 16 * 1024;
+    const maxSpriteBytes = options.maxSpriteBytes ?? 16 * 1024 * 1024;
+    if (!Number.isSafeInteger(maxManifestBytes) || maxManifestBytes <= 0)
+        throw new PetValidationError('manifest byte limit is invalid');
+    if (!Number.isSafeInteger(maxSpriteBytes) || maxSpriteBytes <= 0)
+        throw new PetValidationError('spritesheet byte limit is invalid');
+    if (manifestBytes.byteLength > maxManifestBytes)
+        throw new PetValidationError('pet manifest exceeds the configured byte limit');
+    if (spritesheetBytes.byteLength === 0 || spritesheetBytes.byteLength > maxSpriteBytes)
+        throw new PetValidationError('pet spritesheet exceeds the configured byte limit');
+    parseManifest(manifestBytes, { width: PET_COMPAT_ATLAS.width, height: PET_COMPAT_ATLAS.height });
+    const dimensions = webpDimensions(spritesheetBytes);
+    const pet = parseManifest(manifestBytes, dimensions);
+    const assetUrl = options.assetUrl ?? '';
+    if (assetUrl !== '' && !isOriginRelativePathname(assetUrl))
+        throw new PetValidationError('pet assetUrl must be an origin-relative pathname');
+    const descriptor = Object.freeze({
+        id: pet.id,
+        source: options.source,
+        displayName: pet.displayName,
+        ...(pet.description === '' ? {} : { description: pet.description }),
+        frame: pet.frame,
+        animations: pet.animations,
+        assetUrl,
+    });
+    return Object.freeze({ descriptor, spritesheetPath: pet.spritesheetPath });
+}
+/** Resolve the safe relative spritesheet location before reading the image file.
+ * @param manifestBytes - bounded UTF-8 pet.json bytes.
+ * @returns the manifest-relative spritesheet path.
+ */
+export function petSpritesheetPath(manifestBytes) {
+    return parseManifest(manifestBytes, {
+        width: PET_COMPAT_ATLAS.width,
+        height: PET_COMPAT_ATLAS.height,
+    }).spritesheetPath;
+}
+/** Convert a host activity record into the pet's display status.
+ * @param record - detached host activity record.
+ * @returns the display status, or `undefined` when the record is idle.
+ */
+export function petStatusForHostActivity(record) {
+    if (record.pendingInteraction !== undefined)
+        return 'needs-input';
+    if (record.status === 'blocked')
+        return 'blocked';
+    if (record.completed)
+        return 'ready';
+    if (record.status === 'running')
+        return 'running';
+    return undefined;
+}
+function statusToAnimationState(status) {
+    switch (status) {
+        case 'needs-input': return 'waiting';
+        case 'blocked': return 'failed';
+        case 'ready': return 'review';
+        case 'running': return 'running';
+        default: return 'idle';
+    }
+}
+function requirePetId(value) {
+    if (typeof value !== 'string' || value.length === 0 || value.length > 64)
+        throw new TypeError('pet preference selectedPetId must be a non-empty string');
+    return value;
+}
+function requireBoolean(value, name) {
+    if (typeof value !== 'boolean')
+        throw new TypeError(`pet preference ${name} must be boolean`);
+    return value;
+}
+function isRecord(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+function webpDimensions(bytes) {
+    assertCompleteWebp(bytes);
+    const dimensions = imageDimensionsFromData(bytes);
+    if (dimensions?.type !== 'webp')
+        throw new PetValidationError('pet spritesheet must be a valid WebP image');
+    return { width: dimensions.width, height: dimensions.height };
+}
+function assertCompleteWebp(bytes) {
+    if (bytes.length < 20 || ascii(bytes, 0, 4) !== 'RIFF' || ascii(bytes, 8, 4) !== 'WEBP') {
+        throw new PetValidationError('pet spritesheet must be a valid WebP image');
+    }
+    if (readUint32(bytes, 4) + 8 !== bytes.length)
+        throw new PetValidationError('pet spritesheet must be a valid WebP image');
+    let offset = 12;
+    let hasImagePayload = false;
+    while (offset + 8 <= bytes.length) {
+        const chunk = ascii(bytes, offset, 4);
+        const size = readUint32(bytes, offset + 4);
+        const data = offset + 8;
+        if (data + size > bytes.length)
+            throw new PetValidationError('pet spritesheet must be a valid WebP image');
+        if (chunk === 'VP8 ' && size >= 10 && (readByte(bytes, data) & 1) === 0
+            && bytes[data + 3] === 0x9d && bytes[data + 4] === 0x01 && bytes[data + 5] === 0x2a)
+            hasImagePayload = true;
+        if (chunk === 'VP8L' && size >= 5 && bytes[data] === 0x2f)
+            hasImagePayload = true;
+        offset = data + size + (size % 2);
+    }
+    if (offset !== bytes.length || !hasImagePayload)
+        throw new PetValidationError('pet spritesheet must be a valid WebP image');
+}
+function parseManifest(manifestBytes, dimensions) {
+    let value;
+    try {
+        value = JSON.parse(new TextDecoder('utf-8', { fatal: true }).decode(manifestBytes));
+    }
+    catch {
+        throw new PetValidationError('pet manifest must be valid UTF-8 JSON');
+    }
+    if (!isRecord(value) || Array.isArray(value))
+        throw new PetValidationError('pet manifest must be a JSON object');
+    const allowed = new Set(['id', 'displayName', 'description', 'spritesheetPath', 'frame', 'animations', 'kind', 'spriteVersionNumber']);
+    for (const key of Object.keys(value))
+        if (!allowed.has(key))
+            throw new PetValidationError(`pet manifest contains unsupported field ${key}`);
+    const id = value.id;
+    if (typeof id !== 'string' || !/^[\p{L}][\p{L}\p{N}._-]{0,63}$/u.test(id))
+        throw new PetValidationError('pet manifest id is invalid');
+    const displayName = value.displayName;
+    if (typeof displayName !== 'string' || displayName.length === 0 || displayName.length > 80)
+        throw new PetValidationError('pet manifest displayName is invalid');
+    const description = value.description;
+    if (description !== undefined && (typeof description !== 'string' || description.length > 500))
+        throw new PetValidationError('pet manifest description is invalid');
+    const parsed = parsePetPackage({ ...value, spritesheetDimensions: dimensions });
+    if (!parsed.accepted)
+        throw new PetValidationError(`pet package is incompatible: ${parsed.reason}`);
+    return parsed.pet;
+}
+function ascii(bytes, offset, length) {
+    return String.fromCharCode(...bytes.subarray(offset, offset + length));
+}
+function readUint32(bytes, offset) {
+    return readByte(bytes, offset)
+        + (readByte(bytes, offset + 1) << 8)
+        + (readByte(bytes, offset + 2) << 16)
+        + (readByte(bytes, offset + 3) * 0x1000000);
+}
+function readByte(bytes, offset) {
+    const value = bytes[offset];
+    if (value === undefined)
+        throw new PetValidationError('pet spritesheet has a truncated chunk');
+    return value;
+}
+function isOriginRelativePathname(value) {
+    if (!value.startsWith('/') || value.startsWith('//'))
+        return false;
+    const parsed = new URL(value, 'http://dsh.local');
+    return parsed.origin === 'http://dsh.local' && parsed.pathname === value && parsed.search === '' && parsed.hash === '';
+}
+//# sourceMappingURL=runtime.js.map

package/lib/types/types.d.ts

@@ -0,0 +1,147 @@
+/**
+ * Client-safe types for durable pet preferences and globally aggregated
+ * session activity.
+ * @module @luv1211/dsh-pet/types
+ */
+import type { SessionId } from '@deepseek-ai/dsh-session/types';
+import type { PetAnimation, PetFrameGeometry } from '@luv1211/dsh-pet-compat/types';
+/** The only durable preference document accepted by the compatible pet domain. */
+export interface PetPreference {
+    /** Schema version of the preference document. */
+    readonly version: 3;
+    /** Identifier of the selected built-in or imported pet package. */
+    readonly selectedPetId: string;
+    /** Whether the selected pet is awake and rendered by companion clients. */
+    readonly awake: boolean;
+    /** Logical CSS height of one atlas cell. */
+    readonly sizePx: number;
+}
+/** A validated compatible package descriptor safe to expose to clients. */
+export interface PetDescriptor {
+    /** Stable package identifier. */
+    readonly id: string;
+    /** Whether the catalog loaded the package from its embedded assets or the user root. */
+    readonly source: 'builtin' | 'user';
+    /** Human-readable package name. */
+    readonly displayName: string;
+    /** Optional bounded package description. */
+    readonly description?: string;
+    /** Validated sprite-cell geometry. */
+    readonly frame: PetFrameGeometry;
+    /** Validated named animation tracks. */
+    readonly animations: Readonly<Record<string, PetAnimation>>;
+    /** Origin-relative URL for the validated spritesheet. */
+    readonly assetUrl: string;
+}
+/** Detached catalog read model. */
+export interface PetCatalog {
+    /** Immutable built-in and user package descriptors in deterministic order. */
+    readonly pets: readonly PetDescriptor[];
+}
+/** Native operations advertised by the current host composition. */
+export interface PetHostCapabilities {
+    /** True when a host-native package picker is available. */
+    readonly canImport: boolean;
+    /** True when the host can open the DSH pet directory. */
+    readonly canOpenFolder: boolean;
+}
+/** Pending interaction kinds the host activity projection can report. */
+export type PetPendingInteraction = 'approval' | 'plan-review' | 'question';
+/** Host-owned session activity record consumed by the pet adapter. */
+export interface PetHostActivityRecord {
+    /** Opaque session identifier. */
+    readonly sessionId: SessionId;
+    /** Stable display fallback. */
+    readonly title: string;
+    /** Host's current coarse session condition. */
+    readonly status: 'running' | 'blocked' | 'idle';
+    /** Epoch ms when the host condition changed. */
+    readonly since: number;
+    /** Pending interaction, when user input currently blocks progress. */
+    readonly pendingInteraction?: PetPendingInteraction;
+    /** Whether the host still exposes a completion notification for this session. */
+    readonly completed: boolean;
+}
+/** Host activity projection seam used by PetService. */
+export interface PetActivitySource {
+    /** Read a detached current host projection. */
+    getSnapshot(): readonly PetHostActivityRecord[];
+    /** Subscribe to detached projection replacements and return its disposer. */
+    subscribe(listener: (records: readonly PetHostActivityRecord[]) => void): () => void;
+}
+/** Bytes selected by a host-native package picker; the client never supplies a path. */
+export interface PetPackageBytes {
+    /** UTF-8 compatible pet.json bytes. */
+    readonly manifestBytes: Uint8Array;
+    /** Validated by PetService before publication. */
+    readonly spritesheetBytes: Uint8Array;
+}
+/** Native-only operations supplied by a local host composition. */
+export interface PetNativeActions {
+    /** Open the native package chooser and return bytes, or null on cancellation. */
+    pickPetPackage(): Promise<PetPackageBytes | null>;
+    /** Open one service-owned directory; hosts never accept a client-supplied path here. */
+    openPetFolder(path: string): Promise<void>;
+}
+/** Result of a Remote import request with no native host capability. */
+export type PetImportResult = {
+    readonly outcome: 'published';
+    readonly pet: PetDescriptor;
+} | {
+    readonly outcome: 'cancelled' | 'host-unavailable';
+};
+/** Result of a Remote request to open the DSH pet directory. */
+export type PetFolderResult = {
+    readonly outcome: 'opened';
+} | {
+    readonly outcome: 'host-unavailable';
+};
+declare module '@deepseek-ai/cordis' {
+    interface Context {
+        /** Optional host-owned activity projection consumed by the pet service. */
+        petActivity?: PetActivitySource;
+        /** Optional native-only pet actions; browser compositions leave it absent. */
+        petNative?: PetNativeActions;
+    }
+}
+/** The user-facing urgency states of one live session. */
+export type PetActivityStatus = 'running' | 'needs-input' | 'ready' | 'blocked';
+/** One current activity record aggregated from a live session. */
+export interface PetSessionActivity {
+    /** Opaque identifier of the represented session. */
+    readonly sessionId: SessionId;
+    /** Stable display fallback for clients that have not loaded a session title. */
+    readonly title: string;
+    /** Current user-action urgency. */
+    readonly status: PetActivityStatus;
+    /** Epoch ms when the activity entered its current status. */
+    readonly since: number;
+}
+/** The remote pet read model: durable preference plus ordered live activity. */
+export interface PetSnapshot {
+    /** Persisted user preference. */
+    readonly preference: PetPreference;
+    /** Validated package catalog. */
+    readonly catalog: PetCatalog;
+    /** Host-local absolute path of the user package root, for display beside the managed-directory actions. */
+    readonly petRoot: string;
+    /** Capability flags used to gate native-only controls. */
+    readonly capabilities: PetHostCapabilities;
+    /** All live-session records in deterministic selection order. */
+    readonly activities: readonly PetSessionActivity[];
+    /** Highest-priority activity when one exists. */
+    readonly selectedActivity?: PetSessionActivity;
+}
+declare module '@deepseek-ai/cordis' {
+    interface Events {
+        /**
+         * The pet service published a fresh durable preference or live activity
+         * snapshot. Preference mutations are emitted after the settings provider
+         * persists the namespace.
+         * @param snapshot - detached fresh preference and ordered activity records.
+         * @mode emit
+         */
+        'pet/update'(snapshot: PetSnapshot): void;
+    }
+}
+//# sourceMappingURL=types.d.ts.map

package/lib/types/types.js

@@ -0,0 +1,7 @@
+/**
+ * Client-safe types for durable pet preferences and globally aggregated
+ * session activity.
+ * @module @luv1211/dsh-pet/types
+ */
+export {};
+//# sourceMappingURL=types.js.map

package/package.json

@@ -0,0 +1,111 @@
+{
+  "name": "@luv1211/dsh-pet",
+  "description": "Global settings-backed desktop pet companion with a Remote activity surface",
+  "version": "0.1.1-rc.2",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/deepseek-ai/deepseek-harness.git",
+    "directory": "packages/pet/pet"
+  },
+  "type": "module",
+  "main": "lib/index.js",
+  "types": "lib/types/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./lib/types/index.d.ts",
+      "default": "./lib/index.js"
+    },
+    "./invariant": {
+      "types": "./lib/types/invariant.d.ts",
+      "default": "./lib/invariant.js"
+    },
+    "./types": {
+      "types": "./lib/types/types.d.ts",
+      "default": "./lib/types/types.js"
+    },
+    "./client": {
+      "types": "./lib/types/client.d.ts",
+      "default": "./lib/types/client.js"
+    },
+    "./runtime": {
+      "types": "./lib/types/runtime.d.ts",
+      "default": "./lib/types/runtime.js"
+    },
+    "./renderer": {
+      "types": "./lib/types/renderer.d.ts",
+      "default": "./lib/types/renderer.js"
+    },
+    "./typert": {
+      "types": "./lib/typert.host.d.ts",
+      "default": "./lib/typert.host.js"
+    },
+    "./remote": {
+      "types": "./lib/typert.remote-client.d.ts",
+      "default": "./lib/typert.remote-client.js"
+    },
+    "./src/*": "./src/*",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "lib/index.js",
+    "lib/invariant.js",
+    "assets",
+    "lib/types/**/*.js",
+    "lib/types/**/*.d.ts",
+    "lib/typert.host.js",
+    "lib/typert.host.d.ts",
+    "lib/typert.remote-client.js",
+    "lib/typert.remote-client.d.ts"
+  ],
+  "license": "MIT",
+  "peerDependencies": {
+    "@deepseek-ai/cordis": "^4.0.1-rc.4",
+    "@deepseek-ai/dsh-goal": "^0.1.1-rc.2",
+    "@deepseek-ai/dsh-home-paths": "^0.1.1-rc.2",
+    "@deepseek-ai/dsh-host-directory-picker": "^0.1.1-rc.2",
+    "@deepseek-ai/dsh-host-webserver": "^0.1.1-rc.2",
+    "@deepseek-ai/dsh-invariants": "^0.1.1-rc.2",
+    "@deepseek-ai/dsh-llm": "^0.1.1-rc.2",
+    "@deepseek-ai/dsh-native-command": "^0.1.1-rc.2",
+    "@deepseek-ai/dsh-session": "^0.1.1-rc.2",
+    "@deepseek-ai/dsh-session-projection": "^0.1.1-rc.2",
+    "@deepseek-ai/dsh-settings": "^0.1.1-rc.2",
+    "@deepseek-ai/dsh-subprocess": "^0.1.1-rc.2",
+    "@deepseek-ai/dsh-typert-protocol": "^0.1.1-rc.2",
+    "@luv1211/dsh-desktop-companion": "^0.1.1-rc.2",
+    "@luv1211/dsh-pet-compat": "^0.1.1-rc.2"
+  },
+  "dependencies": {
+    "@deepseek-ai/schemastery": "^3.18.1-rc.4",
+    "image-dimensions": "^2.5.1",
+    "sharp": "0.35.3",
+    "zod": "^4.4.3"
+  },
+  "devDependencies": {
+    "@deepseek-ai/cordis": "^4.0.1-rc.4",
+    "@deepseek-ai/cordis-plugin-include": "^1.0.6-rc.4",
+    "@deepseek-ai/cordis-plugin-loader": "^1.0.2-rc.4",
+    "@deepseek-ai/dsh-goal": "^0.1.1-rc.2",
+    "@deepseek-ai/dsh-home-paths": "^0.1.1-rc.2",
+    "@deepseek-ai/dsh-host-directory-picker": "^0.1.1-rc.2",
+    "@deepseek-ai/dsh-host-webserver": "^0.1.1-rc.2",
+    "@deepseek-ai/dsh-invariants": "^0.1.1-rc.2",
+    "@deepseek-ai/dsh-llm": "^0.1.1-rc.2",
+    "@deepseek-ai/dsh-loader-smoke": "^0.1.1-rc.2",
+    "@deepseek-ai/dsh-native-command": "^0.1.1-rc.2",
+    "@deepseek-ai/dsh-session": "^0.1.1-rc.2",
+    "@deepseek-ai/dsh-session-projection": "^0.1.1-rc.2",
+    "@deepseek-ai/dsh-settings": "^0.1.1-rc.2",
+    "@deepseek-ai/dsh-settings-file": "^0.1.1-rc.2",
+    "@deepseek-ai/dsh-subprocess": "^0.1.1-rc.2",
+    "@deepseek-ai/dsh-typert-protocol": "^0.1.1-rc.2",
+    "@luv1211/dsh-desktop-companion": "^0.1.1-rc.2",
+    "@luv1211/dsh-pet-compat": "^0.1.1-rc.2"
+  },
+  "scripts": {
+    "bundle": "tsdown"
+  }
+}