@crvouga/mockingbird-service-plane 2.1.0 → 2.3.0

package/dist/{chunk-4RCG3YYZ.js → chunk-IBJ4UB3V.js}

@@ -3,7 +3,7 @@ import {
   createRuntime,
   parseDuration,
   resolveAdminPrefix
-} from "./chunk-NSDJM2TL.js";
+} from "./chunk-7ZEMJWNY.js";
 
 // ../../adapters/node/dist/cli.js
 import { readFile as readFile2 } from "node:fs/promises";
@@ -843,4 +843,4 @@ export {
   createServer2 as createServer,
   serveTarget
 };
-//# sourceMappingURL=chunk-4RCG3YYZ.js.map
+//# sourceMappingURL=chunk-IBJ4UB3V.js.map

package/dist/cli.js

@@ -3,8 +3,8 @@ import {
   runCli,
   serveCommand,
   serveTarget
-} from "./chunk-4RCG3YYZ.js";
-import "./chunk-NSDJM2TL.js";
+} from "./chunk-IBJ4UB3V.js";
+import "./chunk-7ZEMJWNY.js";
 
 // src/cli.ts
 var code = await runCli(

package/dist/index.d.ts

@@ -10,36 +10,6 @@ interface FetchAPI$1 {
     fetch(request: Request): Promise<Response>;
 }
 
-/**
- * The single source of time for a service.
- *
- * Every timestamp a mock writes reads from here, so a suite moves time instead of
- * sleeping: appointment windows, result delays and expiries become reachable in
- * milliseconds. A frozen clock also makes timestamps reproducible from a seed.
- */
-type ClockState = {
-    /** Current epoch milliseconds. */
-    now: number;
-    /** True while time does not advance on its own. */
-    frozen: boolean;
-    /** Milliseconds this clock adds to its underlying source. */
-    offsetMs: number;
-};
-type Clock = {
-    now(): number;
-    /** Pin the clock to an exact instant, keeping it frozen if it already was. */
-    set(epochMs: number): void;
-    /** Move the clock forward, or back with a negative delta. */
-    advance(deltaMs: number): void;
-    /** Stop time at the current instant. */
-    freeze(): void;
-    /** Resume from the current instant. */
-    unfreeze(): void;
-    /** Drop back to the underlying source, live. */
-    reset(): void;
-    state(): ClockState;
-};
-
 /** Bind values accepted by Mockingbird's SQLite port (matches sqlite-mem / better-sqlite3). */
 type SqliteValue$1 = null | number | bigint | string | Uint8Array | boolean;
 /** Mutation counters returned by {@link SqliteStatement.run}. */
@@ -111,6 +81,139 @@ declare class Collection<T> {
     }>;
 }
 
+/** A stable identifier for a point in a {@link Timeline}. */
+type CheckpointId = string;
+/** An immutable node in a timeline's checkpoint DAG. */
+type Checkpoint<T> = Readonly<{
+    id: CheckpointId;
+    branch: string;
+    parent: CheckpointId | null;
+    /** Logical time supplied by the timeline's injected clock. */
+    at: number;
+    value: T;
+}>;
+type TimelineOptions = {
+    /** Logical clock used to stamp checkpoints. Defaults to a deterministic counter. */
+    now?: () => number;
+    /** Maximum retained checkpoints. Branch heads are never collected. Default 1,000. */
+    maxCheckpoints?: number;
+    /** Customize deterministic checkpoint IDs. */
+    id?: (sequence: number) => CheckpointId;
+};
+type CommitOptions = {
+    branch?: string;
+    /** Parent checkpoint. Defaults to the selected branch's current head. */
+    parent?: CheckpointId | null;
+};
+type ForkOptions = {
+    /** Checkpoint to fork from. Defaults to the main branch's head. */
+    from?: CheckpointId;
+};
+/**
+ * Small, storage-agnostic checkpoint DAG shared by service runtimes. Its values may be immutable
+ * records, namespace images, or copy-on-write SQL engine snapshots.
+ *
+ * Values are retained by reference. Engines can therefore use persistent/COW snapshots while
+ * simpler services can use immutable values. IDs and GC order are deterministic, and all IO
+ * (the logical clock) is injected.
+ */
+declare class Timeline<T> {
+    readonly maxCheckpoints: number;
+    private readonly now;
+    private readonly makeId;
+    private readonly nodes;
+    private readonly heads;
+    /** Unreferenced nodes in the exact order they became collectible. */
+    private readonly evictable;
+    /** Branch heads plus explicit retainers. Absent means zero. */
+    private readonly references;
+    private readonly explicitPins;
+    private sequence;
+    constructor(options?: TimelineOptions);
+    /** Capture a new immutable value and move `branch` to it. */
+    commit(value: T, options?: CommitOptions): Checkpoint<T>;
+    /** Create a branch pointer without copying its checkpoint value. */
+    fork(branch: string, options?: ForkOptions): Checkpoint<T> | undefined;
+    /** Move a branch pointer to an existing checkpoint. */
+    checkout(branch: string, id: CheckpointId): Checkpoint<T>;
+    get(id: CheckpointId): Checkpoint<T>;
+    head(branch?: string): Checkpoint<T> | undefined;
+    hasBranch(branch: string): boolean;
+    branches(): Readonly<Record<string, CheckpointId>>;
+    checkpoints(): readonly Checkpoint<T>[];
+    /** Number of retained checkpoints without allocating an array. */
+    get size(): number;
+    /** Pin a checkpoint independently of branch heads (used by compatibility snapshot handles). */
+    retain(id: CheckpointId): Checkpoint<T>;
+    /** Release one explicit pin. Branch heads remain pinned until moved or deleted. */
+    release(id: CheckpointId): boolean;
+    deleteBranch(branch: string): boolean;
+    /**
+     * Deterministically discard oldest unpinned checkpoints. Collection is O(number removed):
+     * commits never scan pinned nodes or the retained history. Parents are metadata rather than a
+     * storage dependency, so a retained node remains usable after pruning.
+     */
+    gc(max?: number): CheckpointId[];
+    private collect;
+    private moveHead;
+    private addReference;
+    private removeReference;
+    private assertBranch;
+}
+
+/**
+ * Anything that can answer a Fetch `Request` with a `Response`.
+ *
+ * Every Mockingbird service implements this, and every runtime adapter consumes it.
+ * It is the only contract shared across the whole graph.
+ */
+interface FetchAPI {
+    fetch(request: Request): Promise<Response>;
+}
+
+/** Options every provider constructor accepts. */
+type APIOptions = {
+    /** Sync SQLite client. Defaults to `@crvouga/mockingbird-service-sqlite`. */
+    sqlite?: SqliteClient$1;
+    /** Clock used for `created`-style fields. Default `Date.now`. */
+    now?: () => number;
+    /**
+     * Storage namespace for this instance's records. Instances sharing one SQLite
+     * client stay isolated when their namespaces differ. Defaults to the service name.
+     */
+    namespace?: string;
+};
+
+/**
+ * The single source of time for a service.
+ *
+ * Every timestamp a mock writes reads from here, so a suite moves time instead of
+ * sleeping: appointment windows, result delays and expiries become reachable in
+ * milliseconds. A frozen clock also makes timestamps reproducible from a seed.
+ */
+type ClockState = {
+    /** Current epoch milliseconds. */
+    now: number;
+    /** True while time does not advance on its own. */
+    frozen: boolean;
+    /** Milliseconds this clock adds to its underlying source. */
+    offsetMs: number;
+};
+type Clock = {
+    now(): number;
+    /** Pin the clock to an exact instant, keeping it frozen if it already was. */
+    set(epochMs: number): void;
+    /** Move the clock forward, or back with a negative delta. */
+    advance(deltaMs: number): void;
+    /** Stop time at the current instant. */
+    freeze(): void;
+    /** Resume from the current instant. */
+    unfreeze(): void;
+    /** Drop back to the underlying source, live. */
+    reset(): void;
+    state(): ClockState;
+};
+
 /**
  * Seeded pseudo-random numbers, so anything a mock invents — ids, jitter, which
  * request a percentage fault hits — is reproducible from a seed.
@@ -251,109 +354,6 @@ type FaultRegistry = {
     take(candidate: FaultCandidate): Promise<FaultHit[]>;
 };
 
-/** A stable identifier for a point in a {@link Timeline}. */
-type CheckpointId = string;
-/** An immutable node in a timeline's checkpoint DAG. */
-type Checkpoint<T> = Readonly<{
-    id: CheckpointId;
-    branch: string;
-    parent: CheckpointId | null;
-    /** Logical time supplied by the timeline's injected clock. */
-    at: number;
-    value: T;
-}>;
-type TimelineOptions = {
-    /** Logical clock used to stamp checkpoints. Defaults to a deterministic counter. */
-    now?: () => number;
-    /** Maximum retained checkpoints. Branch heads are never collected. Default 1,000. */
-    maxCheckpoints?: number;
-    /** Customize deterministic checkpoint IDs. */
-    id?: (sequence: number) => CheckpointId;
-};
-type CommitOptions = {
-    branch?: string;
-    /** Parent checkpoint. Defaults to the selected branch's current head. */
-    parent?: CheckpointId | null;
-};
-type ForkOptions = {
-    /** Checkpoint to fork from. Defaults to the main branch's head. */
-    from?: CheckpointId;
-};
-/**
- * Small, storage-agnostic checkpoint DAG shared by service runtimes. Its values may be immutable
- * records, namespace images, or copy-on-write SQL engine snapshots.
- *
- * Values are retained by reference. Engines can therefore use persistent/COW snapshots while
- * simpler services can use immutable values. IDs and GC order are deterministic, and all IO
- * (the logical clock) is injected.
- */
-declare class Timeline<T> {
-    readonly maxCheckpoints: number;
-    private readonly now;
-    private readonly makeId;
-    private readonly nodes;
-    private readonly heads;
-    /** Unreferenced nodes in the exact order they became collectible. */
-    private readonly evictable;
-    /** Branch heads plus explicit retainers. Absent means zero. */
-    private readonly references;
-    private readonly explicitPins;
-    private sequence;
-    constructor(options?: TimelineOptions);
-    /** Capture a new immutable value and move `branch` to it. */
-    commit(value: T, options?: CommitOptions): Checkpoint<T>;
-    /** Create a branch pointer without copying its checkpoint value. */
-    fork(branch: string, options?: ForkOptions): Checkpoint<T> | undefined;
-    /** Move a branch pointer to an existing checkpoint. */
-    checkout(branch: string, id: CheckpointId): Checkpoint<T>;
-    get(id: CheckpointId): Checkpoint<T>;
-    head(branch?: string): Checkpoint<T> | undefined;
-    hasBranch(branch: string): boolean;
-    branches(): Readonly<Record<string, CheckpointId>>;
-    checkpoints(): readonly Checkpoint<T>[];
-    /** Number of retained checkpoints without allocating an array. */
-    get size(): number;
-    /** Pin a checkpoint independently of branch heads (used by compatibility snapshot handles). */
-    retain(id: CheckpointId): Checkpoint<T>;
-    /** Release one explicit pin. Branch heads remain pinned until moved or deleted. */
-    release(id: CheckpointId): boolean;
-    deleteBranch(branch: string): boolean;
-    /**
-     * Deterministically discard oldest unpinned checkpoints. Collection is O(number removed):
-     * commits never scan pinned nodes or the retained history. Parents are metadata rather than a
-     * storage dependency, so a retained node remains usable after pruning.
-     */
-    gc(max?: number): CheckpointId[];
-    private collect;
-    private moveHead;
-    private addReference;
-    private removeReference;
-    private assertBranch;
-}
-
-/**
- * Anything that can answer a Fetch `Request` with a `Response`.
- *
- * Every Mockingbird service implements this, and every runtime adapter consumes it.
- * It is the only contract shared across the whole graph.
- */
-interface FetchAPI {
-    fetch(request: Request): Promise<Response>;
-}
-
-/** Options every provider constructor accepts. */
-type APIOptions = {
-    /** Sync SQLite client. Defaults to `@crvouga/mockingbird-service-sqlite`. */
-    sqlite?: SqliteClient$1;
-    /** Clock used for `created`-style fields. Default `Date.now`. */
-    now?: () => number;
-    /**
-     * Storage namespace for this instance's records. Instances sharing one SQLite
-     * client stay isolated when their namespaces differ. Defaults to the service name.
-     */
-    namespace?: string;
-};
-
 /**
  * One problem with a request body, at a dotted path (`patient.address.city`, `items.0.sku`).
  * `kind` is `media_type` when the body is present but its media type is not one the operation
@@ -395,6 +395,10 @@ type RequestLog = {
     ids?: Record<string, string>;
     /** Set when the service created a resource the request referred to but that did not exist. */
     adopted?: boolean;
+    /** Explicit durable acceptance, independent of response delivery. */
+    accepted?: boolean;
+    /** Checkpoint captured at explicit acceptance. */
+    checkpoint?: string;
     /** Set on a rejection (status ≥ 400) the mock produced itself, never on a scripted fault. */
     request?: RejectedRequest;
     /** The validation issues behind a rejection, when the service found any. */
@@ -715,6 +719,8 @@ type PlaneWorkItemRecord = {
     description_stripped: string | null;
     priority: "urgent" | "high" | "medium" | "low" | "none";
     state: string;
+    type_id: string | null;
+    type: string | null;
     labels: string[];
     assignees: string[];
     parent: string | null;
@@ -754,6 +760,52 @@ type PlaneLinkRecord = {
     created_at: string;
     updated_at: string;
 };
+type PlaneCycleRecord = {
+    id: string;
+    name: string;
+    description: string;
+    start_date: string | null;
+    end_date: string | null;
+    owned_by: string | null;
+    timezone: string;
+    external_source: string | null;
+    external_id: string | null;
+    project: string;
+    workspace: string;
+    created_at: string;
+    updated_at: string;
+    archived_at: string | null;
+    deleted_at: string | null;
+};
+type PlaneCycleMembership = {
+    id: string;
+    cycle: string;
+    issue: string;
+    project: string;
+    workspace: string;
+    created_at: string;
+    updated_at: string;
+    deleted_at: string | null;
+};
+type PlaneWorkItemType = {
+    id: string;
+    name: string;
+    description: string;
+    project_ids: string[];
+    logo_props: Record<string, unknown>;
+    is_epic: boolean;
+    is_default: boolean;
+    is_active: boolean;
+    level: number;
+    created_at: string;
+    updated_at: string;
+    deleted_at: string | null;
+};
+type WorkItemTypeSeed = {
+    name: string;
+    description?: string;
+    is_default?: boolean;
+};
 /** One project: its workspace slug and the per-project work-item sequence. */
 type ProjectRecord = {
     id: string;
@@ -786,6 +838,9 @@ declare class PlaneState {
     readonly items: Collection<PlaneWorkItemRecord>;
     readonly comments: Collection<PlaneCommentRecord>;
     readonly links: Collection<PlaneLinkRecord>;
+    readonly cycles: Collection<PlaneCycleRecord>;
+    readonly memberships: Collection<PlaneCycleMembership>;
+    readonly types: Collection<PlaneWorkItemType>;
     readonly settings: Collection<Settings>;
     readonly rateLimits: Collection<number>;
     private readonly ids;
@@ -963,10 +1018,10 @@ type OpenAPIDocument = {
 };
 
 declare const document: OpenAPIDocument;
-type OperationId = "ListWorkItems" | "CreateWorkItem" | "GetWorkItem" | "UpdateWorkItem" | "ListComments" | "CreateComment" | "ListLinks" | "CreateLink" | "ListStates" | "ListLabels" | "CreateLabel";
-type SupportedOperationId = "ListWorkItems" | "CreateWorkItem" | "GetWorkItem" | "UpdateWorkItem" | "ListComments" | "CreateComment" | "ListLinks" | "CreateLink" | "ListStates" | "ListLabels" | "CreateLabel";
-declare const operationIds: readonly ["ListWorkItems", "CreateWorkItem", "GetWorkItem", "UpdateWorkItem", "ListComments", "CreateComment", "ListLinks", "CreateLink", "ListStates", "ListLabels", "CreateLabel"];
-declare const supportedOperationIds: readonly ["ListWorkItems", "CreateWorkItem", "GetWorkItem", "UpdateWorkItem", "ListComments", "CreateComment", "ListLinks", "CreateLink", "ListStates", "ListLabels", "CreateLabel"];
+type OperationId = "ListWorkItems" | "CreateWorkItem" | "GetWorkItem" | "UpdateWorkItem" | "ListComments" | "CreateComment" | "ListLinks" | "CreateLink" | "ListStates" | "ListLabels" | "CreateLabel" | "ListCycles" | "CreateCycle" | "ListCycleWorkItems" | "AddCycleWorkItems" | "ListWorkItemTypes";
+type SupportedOperationId = "ListWorkItems" | "CreateWorkItem" | "GetWorkItem" | "UpdateWorkItem" | "ListComments" | "CreateComment" | "ListLinks" | "CreateLink" | "ListStates" | "ListLabels" | "CreateLabel" | "ListCycles" | "CreateCycle" | "ListCycleWorkItems" | "AddCycleWorkItems" | "ListWorkItemTypes";
+declare const operationIds: readonly ["ListWorkItems", "CreateWorkItem", "GetWorkItem", "UpdateWorkItem", "ListComments", "CreateComment", "ListLinks", "CreateLink", "ListStates", "ListLabels", "CreateLabel", "ListCycles", "CreateCycle", "ListCycleWorkItems", "AddCycleWorkItems", "ListWorkItemTypes"];
+declare const supportedOperationIds: readonly ["ListWorkItems", "CreateWorkItem", "GetWorkItem", "UpdateWorkItem", "ListComments", "CreateComment", "ListLinks", "CreateLink", "ListStates", "ListLabels", "CreateLabel", "ListCycles", "CreateCycle", "ListCycleWorkItems", "AddCycleWorkItems", "ListWorkItemTypes"];
 
 /**
  * Every named Plane misbehaviour our bug-report client branches on, switched on with
@@ -1020,11 +1075,20 @@ declare class PlaneAPI implements FetchAPI$1 {
     private item;
     statesOf(projectId: string): PlaneStateRecord[];
     labelsOf(projectId: string): PlaneLabelRecord[];
+    typesOf(projectId: string): PlaneWorkItemType[];
+    /** Idempotent fixture provisioning; type IDs remain stable when metadata is reseeded. */
+    seedWorkItemTypes(workspace: string, projectId: string, types: WorkItemTypeSeed[]): PlaneWorkItemType[] | undefined;
     /** Plane's cursor paginator: `cursor=<per_page>:<page>:<is_prev>`, offset = page × per_page. */
     private paginate;
     private listWorkItems;
+    private cycle;
+    private cycleView;
+    private listCycles;
+    private createCycle;
+    private listCycleWorkItems;
+    private addCycleWorkItems;
     private body;
-    /** Validate `state` / `labels` references against the project, DRF-style. */
+    /** Validate workflow references before any part of a write is persisted, DRF-style. */
     private references;
     private createWorkItem;
     private updateWorkItem;
@@ -1042,4 +1106,4 @@ declare class PlaneAPI implements FetchAPI$1 {
 }
 
 export { DEFAULT_STATES, PLANE_NAMESPACE, PLANE_PRESETS, PlaneAPI, apiKeyCredential, createRuntime, document, operationIds, supportedOperationIds, uuidFrom };
-export type { FetchAPI$1 as FetchAPI, OperationId, PlaneAPIOptions, PlaneCommentRecord, PlaneLabelRecord, PlaneLinkRecord, PlaneRuntime, PlaneRuntimeOptions, PlaneStateRecord, PlaneWorkItemRecord, ProjectRecord, Settings, SqliteClient, StateGroup, SupportedOperationId };
+export type { FetchAPI$1 as FetchAPI, OperationId, PlaneAPIOptions, PlaneCommentRecord, PlaneCycleMembership, PlaneCycleRecord, PlaneLabelRecord, PlaneLinkRecord, PlaneRuntime, PlaneRuntimeOptions, PlaneStateRecord, PlaneWorkItemRecord, PlaneWorkItemType, ProjectRecord, Settings, SqliteClient, StateGroup, SupportedOperationId, WorkItemTypeSeed };

package/dist/index.js

@@ -9,7 +9,7 @@ import {
   operationIds,
   supportedOperationIds,
   uuidFrom
-} from "./chunk-NSDJM2TL.js";
+} from "./chunk-7ZEMJWNY.js";
 export {
   DEFAULT_STATES,
   PLANE_NAMESPACE,