@prettier-ai/dsh-workspace 0.1.2-alpha.1

package/lib/types/paths.js

@@ -0,0 +1,21 @@
+/**
+ * Path canonicalization for workspace identity.
+ * @module @prettier-ai/dsh-workspace/src/paths
+ */
+import { realpath } from 'node:fs/promises';
+/**
+ * Canonicalize a directory path via `fs.realpath`: trailing slashes, `..`
+ * segments, and symlinks are all resolved. This is the ONE uniqueness canon of
+ * the package — workspace paths are stored canonicalized, uniqueness is
+ * string equality of canonicalized paths (a symlink to an existing
+ * workspace's directory collides), and attach-time session `cwd` checks go
+ * through the same canon. A path that does not exist rejects with the
+ * original `ENOENT` — this is `create`'s reject path (a workspace must point
+ * at an existing directory).
+ * @param path - The path to canonicalize.
+ * @returns the canonical absolute path.
+ */
+export async function realpathNormalize(path) {
+    return await realpath(path);
+}
+//# sourceMappingURL=paths.js.map

package/lib/types/spec.d.ts

@@ -0,0 +1,85 @@
+/**
+ * The workspace domain declaration: record schema and the `defineDomain` spec
+ * the registry opens. The zod schema validates the shipped format at the
+ * durability boundary and is the direct source of a future RPC wire projection.
+ * @module @prettier-ai/dsh-workspace/src/spec
+ */
+import { z } from 'zod';
+import { SessionId } from '@prettier-ai/dsh-session';
+import type { WorkspaceId } from './types.ts';
+/**
+ * Durable shape of one workspace record. `path` is the `fs.realpath` canon
+ * stamped at create; `sessionIds` is the ordered ownership account (array
+ * order is display order); timestamps are ISO-8601 strings.
+ */
+export declare const workspaceRecord: z.ZodObject<{
+    path: z.ZodString;
+    title: z.ZodString;
+    sessionIds: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<SessionId, string>>>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+}, z.core.$strip>;
+/** One stored workspace record, inferred from {@link workspaceRecord}. */
+export type WorkspaceRecord = z.infer<typeof workspaceRecord>;
+/**
+ * Durable registry state. `initialized` distinguishes a valid empty registry
+ * from one that still needs the header-only history bootstrap;
+ * `workspaceIds` is the authoritative display order. `archivedSessionIds` is
+ * the registry-global archive set layered over workspace accounting: an
+ * archived session keeps its `sessionIds` slot (unarchiving must restore the
+ * position), so the set never participates in the one-owner accounting
+ * invariant. Defaulted so records written before the field parse unchanged.
+ */
+export declare const workspaceDomainState: z.ZodObject<{
+    initialized: z.ZodBoolean;
+    workspaceIds: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<WorkspaceId, string>>>;
+    archivedSessionIds: z.ZodDefault<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<SessionId, string>>>>;
+    pendingMutation: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        operation: z.ZodLiteral<"create">;
+        workspaceId: z.ZodPipe<z.ZodString, z.ZodTransform<WorkspaceId, string>>;
+    }, z.core.$strip>, z.ZodObject<{
+        operation: z.ZodLiteral<"delete">;
+        workspaceId: z.ZodPipe<z.ZodString, z.ZodTransform<WorkspaceId, string>>;
+    }, z.core.$strip>], "operation">>;
+}, z.core.$strip>;
+/** Durable registry state inferred from {@link workspaceDomainState}. */
+export type WorkspaceDomainState = z.infer<typeof workspaceDomainState>;
+/**
+ * The workspace domain spec: one `workspaces` table keyed by
+ * {@link WorkspaceId} plus the bootstrap/order singleton. The registry opens
+ * this through `ctx.storage.domain`; the spec object is the single source of
+ * the domain's identity, version, and schemas.
+ */
+export declare const workspaceDomainSpec: {
+    name: string;
+    version: number;
+    global: {
+        schema: z.ZodObject<{
+            initialized: z.ZodBoolean;
+            workspaceIds: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<WorkspaceId, string>>>;
+            archivedSessionIds: z.ZodDefault<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<SessionId, string>>>>;
+            pendingMutation: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                operation: z.ZodLiteral<"create">;
+                workspaceId: z.ZodPipe<z.ZodString, z.ZodTransform<WorkspaceId, string>>;
+            }, z.core.$strip>, z.ZodObject<{
+                operation: z.ZodLiteral<"delete">;
+                workspaceId: z.ZodPipe<z.ZodString, z.ZodTransform<WorkspaceId, string>>;
+            }, z.core.$strip>], "operation">>;
+        }, z.core.$strip>;
+        initial: {
+            initialized: boolean;
+            workspaceIds: never[];
+            archivedSessionIds: never[];
+        };
+    };
+    tables: {
+        workspaces: import("@prettier-ai/dsh-storage-domain").DomainTableSpec<WorkspaceId, {
+            path: string;
+            title: string;
+            sessionIds: SessionId[];
+            createdAt: string;
+            updatedAt: string;
+        }>;
+    };
+};
+//# sourceMappingURL=spec.d.ts.map

package/lib/types/spec.js

@@ -0,0 +1,63 @@
+/**
+ * The workspace domain declaration: record schema and the `defineDomain` spec
+ * the registry opens. The zod schema validates the shipped format at the
+ * durability boundary and is the direct source of a future RPC wire projection.
+ * @module @prettier-ai/dsh-workspace/src/spec
+ */
+import { z } from 'zod';
+import { SessionId } from '@prettier-ai/dsh-session';
+import { defineDomain, domainTable } from '@prettier-ai/dsh-storage-domain';
+/** Workspace id schema at the durable boundary; branding has no runtime representation. */
+const workspaceId = z.string().transform(value => value);
+/**
+ * Durable shape of one workspace record. `path` is the `fs.realpath` canon
+ * stamped at create; `sessionIds` is the ordered ownership account (array
+ * order is display order); timestamps are ISO-8601 strings.
+ */
+export const workspaceRecord = z.object({
+    path: z.string(),
+    title: z.string(),
+    sessionIds: z.array(z.string().transform(SessionId)),
+    createdAt: z.string(),
+    updatedAt: z.string(),
+});
+/**
+ * Recoverable two-write mutation marker. The marker is persisted before the
+ * record/order pair can diverge, so startup can distinguish an interrupted
+ * registry operation from unexplained medium corruption.
+ */
+const workspacePendingMutation = z.discriminatedUnion('operation', [
+    z.object({ operation: z.literal('create'), workspaceId }),
+    z.object({ operation: z.literal('delete'), workspaceId }),
+]);
+/**
+ * Durable registry state. `initialized` distinguishes a valid empty registry
+ * from one that still needs the header-only history bootstrap;
+ * `workspaceIds` is the authoritative display order. `archivedSessionIds` is
+ * the registry-global archive set layered over workspace accounting: an
+ * archived session keeps its `sessionIds` slot (unarchiving must restore the
+ * position), so the set never participates in the one-owner accounting
+ * invariant. Defaulted so records written before the field parse unchanged.
+ */
+export const workspaceDomainState = z.object({
+    initialized: z.boolean(),
+    workspaceIds: z.array(workspaceId),
+    archivedSessionIds: z.array(z.string().transform(SessionId)).default([]),
+    pendingMutation: workspacePendingMutation.optional(),
+});
+/**
+ * The workspace domain spec: one `workspaces` table keyed by
+ * {@link WorkspaceId} plus the bootstrap/order singleton. The registry opens
+ * this through `ctx.storage.domain`; the spec object is the single source of
+ * the domain's identity, version, and schemas.
+ */
+export const workspaceDomainSpec = defineDomain({
+    name: 'workspace',
+    version: 2,
+    global: {
+        schema: workspaceDomainState,
+        initial: { initialized: false, workspaceIds: [], archivedSessionIds: [] },
+    },
+    tables: { workspaces: domainTable(workspaceRecord) },
+});
+//# sourceMappingURL=spec.js.map

package/lib/types/types.d.ts

@@ -0,0 +1,92 @@
+/**
+ * Public type vocabulary of the workspace entity: the `WorkspaceId` brand and
+ * the `Workspace` consumer interface. Types only — the `WorkspaceId` factory
+ * lives in `index.ts` (this file carries no runtime code).
+ * @module @prettier-ai/dsh-workspace/src/types
+ */
+import type { Branded } from '@prettier-ai/dsh-brand';
+import type { SessionId } from '@prettier-ai/dsh-session/types';
+/**
+ * Identifies one workspace record. A generated uuid, never the path: path
+ * normalization rewrites paths, and a reference anchor must stay stable.
+ */
+export type WorkspaceId = Branded<'WorkspaceId'>;
+/**
+ * One workspace: a stable id over an existing directory, a display title, and
+ * an ordered candidate account of sessions. Membership requires both an id in
+ * that account and a session header whose canonical cwd equals the workspace
+ * path. Consumers only see this interface; the implementation stays private.
+ */
+export interface Workspace {
+    /** Stable record id (generated uuid). */
+    readonly id: WorkspaceId;
+    /**
+     * Canonical directory path: the `fs.realpath` of the path given at create
+     * time (trailing slashes, `..`, and symlinks all resolved). Never rewritten
+     * afterwards, even when the directory disappears (see {@link status}).
+     */
+    readonly path: string;
+    /** Display title. Defaults to `basename(path)` at create; duplicates are allowed. */
+    readonly title: string;
+    /** ISO-8601 creation instant, stamped at create and never rewritten. */
+    readonly createdAt: string;
+    /** ISO-8601 instant of the last durable mutation (create counts as one). */
+    readonly updatedAt: string;
+    /**
+     * Header-validated sessions in manually owned order: a new session is
+     * prepended at attach, explicit reordering goes through
+     * `insertSessionBefore`, and activity never reorders. The durable candidate
+     * account is filtered synchronously: missing headers, invalid cwd values,
+     * and canonical cwd mismatches are never returned. A subsequent workspace
+     * mutation prunes those filtered candidates durably.
+     */
+    readonly sessionIds: readonly SessionId[];
+    /**
+     * Replace the display title durably.
+     * @param title - New title; any string, duplicates across workspaces allowed.
+     * @returns resolution after durability.
+     */
+    setTitle(title: string): Promise<void>;
+    /**
+     * Prepend a session to this workspace's candidate account. An already
+     * accounted id resolves without writing, aside from the durable
+     * filtered-candidate prune every accepted mutation performs. A new id's
+     * live or persisted
+     * header cwd must resolve to an existing directory equal to {@link path};
+     * unknown ids, missing or invalid cwd values, and mismatches reject without
+     * writing.
+     * @param sessionId - The session to record.
+     * @returns resolution after durability.
+     */
+    attachSession(sessionId: SessionId): Promise<void>;
+    /**
+     * Move an accounted session within the manual order, DOM-insertBefore-like:
+     * with an anchor the session lands before it, without one it appends to the
+     * end. Only the moved id changes position. A session or anchor absent from
+     * the account rejects without writing; a move to the current position
+     * resolves without writing, aside from the durable filtered-candidate
+     * prune every accepted mutation performs; decided on the domain write
+     * chain.
+     * @param sessionId - The accounted session to move.
+     * @param beforeSessionId - Accounted anchor to insert before; omitted appends.
+     * @returns resolution after durability.
+     */
+    insertSessionBefore(sessionId: SessionId, beforeSessionId?: SessionId): Promise<void>;
+    /**
+     * Remove a session from this workspace's account. Idempotent: an id not on
+     * the account resolves without writing, aside from the durable
+     * filtered-candidate prune every accepted mutation performs; decided on
+     * the domain write chain like attach. Never touches the session's own stored log.
+     * @param sessionId - The session to remove.
+     * @returns resolution after durability.
+     */
+    detachSession(sessionId: SessionId): Promise<void>;
+    /**
+     * Live directory check, uncached: whether {@link path} currently exists and
+     * is a directory. A missing directory never mutates the record — the
+     * directory may only be temporarily moved.
+     * @returns `'ok'` when the directory exists, `'missing-dir'` otherwise.
+     */
+    status(): Promise<'ok' | 'missing-dir'>;
+}
+//# sourceMappingURL=types.d.ts.map

package/lib/types/types.js

@@ -0,0 +1,8 @@
+/**
+ * Public type vocabulary of the workspace entity: the `WorkspaceId` brand and
+ * the `Workspace` consumer interface. Types only — the `WorkspaceId` factory
+ * lives in `index.ts` (this file carries no runtime code).
+ * @module @prettier-ai/dsh-workspace/src/types
+ */
+export {};
+//# sourceMappingURL=types.js.map

package/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "@prettier-ai/dsh-workspace",
+  "description": "Workspace entity registry (ctx.workspaceRegistry): durable workspace records with validated session attachment over the domain data form for the DeepSeek Harness",
+  "version": "0.1.2-alpha.1",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/deepseek-ai/deepseek-harness.git",
+    "directory": "packages/workspace/workspace"
+  },
+  "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"
+    },
+    "./src/*": "./src/*",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "lib/index.js",
+    "lib/invariant.js",
+    "lib/types/**/*.js",
+    "lib/types/**/*.d.ts"
+  ],
+  "license": "MIT",
+  "peerDependencies": {
+    "@prettier-ai/dsh-brand": "^0.1.2-alpha.1",
+    "@prettier-ai/dsh-invariants": "^0.1.2-alpha.1",
+    "@prettier-ai/dsh-storage-domain": "^0.1.2-alpha.1",
+    "@prettier-ai/dsh-session": "^0.1.2-alpha.1",
+    "@prettier-ai/dsh-session-persistence": "^0.1.2-alpha.1",
+    "@prettier-ai/dsh-storage": "^0.1.2-alpha.1",
+    "@prettier-ai/cordis": "^4.0.1"
+  },
+  "dependencies": {
+    "zod": "^4.4.3"
+  },
+  "devDependencies": {
+    "@prettier-ai/dsh-storage-domain": "^0.1.2-alpha.1",
+    "@prettier-ai/dsh-brand": "^0.1.2-alpha.1",
+    "@prettier-ai/dsh-invariants": "^0.1.2-alpha.1",
+    "@prettier-ai/dsh-session": "^0.1.2-alpha.1",
+    "@prettier-ai/dsh-storage": "^0.1.2-alpha.1",
+    "@prettier-ai/dsh-session-persistence": "^0.1.2-alpha.1",
+    "@prettier-ai/cordis": "^4.0.1"
+  }
+}