ex-workflow 0.0.0-stage → 0.2.0-stage

package/dist/index.d.cts

@@ -0,0 +1,134 @@
+import { ErrorCode, WorkflowState, MethodologyName, Stage, Role, Event, WorkItem, Evidence, NewItem, ItemStatus, Policy, Violation, Gate, Transition, PendingHuman, Budget, Accounting, Iteration, Methodology, Brief, Handoff, ApplyResult, Rule, Action } from './types.cjs';
+export { Baseline, Blocker, Capability, Ceremony, CeremonyInput, ClassOfService, CoreTerm, GateRequirement, ItemType, Lesson, LessonChange, ModelTier, Phase, PlannerOptions, Verdict } from './types.cjs';
+export { a as approversFor, c as canDo, h as hasCapability, r as registerRole, b as requireCap, d as requireCapabilities, e as retireRole, f as rolesWith, s as separationLost } from './roles-aneKYJ3Z.cjs';
+import { ExNode } from 'ex-flow';
+
+interface WorkflowErrorExtra {
+    items?: string[];
+    rule?: string;
+}
+declare class WorkflowError extends Error {
+    readonly code: ErrorCode;
+    readonly fix: string;
+    readonly items?: string[];
+    readonly rule?: string;
+    constructor(code: ErrorCode, message: string, fix: string, extra?: WorkflowErrorExtra);
+    toJSON(): {
+        code: ErrorCode;
+        message: string;
+        fix: string;
+        items?: string[];
+        rule?: string;
+    };
+}
+declare function fail(code: ErrorCode, message: string, fix: string, extra?: WorkflowErrorExtra): never;
+/** Ids become object keys and file names: letters, digits, `.`, `_`, `-`; no `..`, no prototype names. */
+declare function assertId(id: unknown, what: string): void;
+
+declare function nowOf(now?: string): string;
+interface CreateStateInput {
+    methodology: MethodologyName;
+    config: unknown;
+    stages: Stage[];
+    roles: Role[];
+    now?: string;
+}
+declare function createState(input: CreateStateInput): WorkflowState;
+declare function appendEvent(state: WorkflowState, type: string, by: string, payload: unknown, now?: string): WorkflowState;
+declare function lastEvent(state: WorkflowState, type?: string): Event | undefined;
+
+declare function stageOf(state: WorkflowState, stageId: string): Stage;
+declare function nextStageOf(state: WorkflowState, stageId: string): Stage | undefined;
+declare function isTerminalStage(state: WorkflowState, stageId: string): boolean;
+declare function getItem(state: WorkflowState, id: string): WorkItem;
+declare function addItem(state: WorkflowState, input: NewItem, by: string, now?: string): WorkflowState;
+type ItemPatch = Partial<Omit<WorkItem, "id" | "stage" | "status" | "transitions" | "evidence" | "blockers">>;
+declare function editItem(state: WorkflowState, id: string, patch: ItemPatch, by: string, now?: string): WorkflowState;
+declare function moveItem(state: WorkflowState, id: string, to: {
+    stage?: string;
+    status: ItemStatus;
+}, by: string, now?: string): WorkflowState;
+declare function addEvidence(state: WorkflowState, id: string, evidence: Omit<Evidence, "at">, now?: string): WorkflowState;
+declare function raiseBlocker(state: WorkflowState, id: string, reason: string, owner: string, by: string, now?: string): WorkflowState;
+declare function clearBlocker(state: WorkflowState, id: string, blockerId: string, by: string, now?: string): WorkflowState;
+
+declare function evaluatePolicies(state: WorkflowState, item: WorkItem, policies: Policy[]): Violation[];
+declare function assertPolicies(state: WorkflowState, item: WorkItem, policies: Policy[], context: string): void;
+
+type GateResult = {
+    outcome: "pass";
+} | {
+    outcome: "human";
+} | {
+    outcome: "fail";
+    violations: Violation[];
+};
+/** Last in_progress dispatch made from a stage that comes STRICTLY BEFORE the item's current stage in `state.stages` order (unknown stage ids count as not-before). */
+declare function lastDispatchBefore(state: WorkflowState, item: WorkItem): Transition | undefined;
+/** Role that did the work the gate guards: the last dispatch made from a stage strictly before the current one (so a reviewer dispatched into the gated stage is not its author); else the last dispatch of any stage; undefined if never dispatched. */
+declare function authorOf(state: WorkflowState, item: WorkItem): string | undefined;
+declare function checkGate(state: WorkflowState, item: WorkItem, gate: Gate, by: string): GateResult;
+declare function raisePending(state: WorkflowState, pending: Omit<PendingHuman, "id" | "raisedAt">, now?: string): WorkflowState;
+declare function decide(state: WorkflowState, pendingId: string, decision: "approve" | "reject", by: string, note: string, now?: string): WorkflowState;
+
+declare const ZERO_SPENT: Required<Budget>;
+declare function addSpent(spent: Required<Budget>, acc: Accounting): Required<Budget>;
+declare function remaining(budget: Budget, spent: Required<Budget>): Budget;
+declare function isExhausted(budget: Budget, spent: Required<Budget>): boolean;
+declare function estimateTokens(state: WorkflowState, weight: number | undefined, fallbackPerWeight?: number): number;
+
+type NodeData = {
+    id: string;
+};
+declare function openIteration(state: WorkflowState): Iteration | undefined;
+declare function assignRole(state: WorkflowState, item: WorkItem): Role;
+declare function resourceCapsFor(state: WorkflowState): Record<string, number>;
+declare function toExNodes(items: WorkItem[], state: WorkflowState, priorityOf?: (item: WorkItem) => number | undefined): ExNode<NodeData>[];
+interface PlanOptions {
+    max?: number;
+    now?: string;
+    fallbackTokensPerWeight?: number;
+}
+type PlanReason = "no-candidates" | "budget-exhausted" | "wip-full" | "policy-blocked";
+/** A ready item the planner did not pull, and why. */
+interface Skipped {
+    id: string;
+    reason: "entry-policy" | "wip" | "resource-cap" | "budget";
+    detail: string;
+}
+interface PlanResult {
+    state: WorkflowState;
+    dispatched: WorkItem[];
+    skipped: Skipped[];
+    reason?: PlanReason;
+}
+declare function plan(state: WorkflowState, methodology: Methodology, opts?: PlanOptions): PlanResult;
+
+declare function synthesizeBrief(state: WorkflowState, methodology: Methodology, item: WorkItem): Brief;
+interface NextResult {
+    state: WorkflowState;
+    briefs: Brief[];
+    skipped: Skipped[];
+    reason?: PlanReason;
+}
+declare function next(state: WorkflowState, methodology: Methodology, opts?: PlanOptions): NextResult;
+
+declare function complete(state: WorkflowState, methodology: Methodology, handoff: Handoff, acc: Accounting, now?: string): ApplyResult;
+
+declare function coreRulesFor(methodology: Pick<Methodology, "requiredCapabilities">): Rule[];
+
+declare function validateAction(state: WorkflowState, methodology: Methodology, action: Action): Violation[];
+declare function applyAction(state: WorkflowState, methodology: Methodology, action: Action, reduce: (s: WorkflowState) => WorkflowState): ApplyResult;
+interface InitInput<C> {
+    methodology: Methodology<C>;
+    config: unknown;
+    roles?: Role[];
+    stages?: Stage[];
+    by?: string;
+    now?: string;
+}
+declare function init<C>(input: InitInput<C>): ApplyResult;
+
+declare const VERSION = "0.2.0-stage";
+
+export { Accounting, Action, ApplyResult, Brief, Budget, ErrorCode, Event, Evidence, Gate, type GateResult, Handoff, type InitInput, type ItemPatch, ItemStatus, Iteration, Methodology, MethodologyName, NewItem, type NextResult, PendingHuman, type PlanOptions, type PlanReason, type PlanResult, Policy, Role, Rule, type Skipped, Stage, Transition, VERSION, Violation, WorkItem, WorkflowError, WorkflowState, ZERO_SPENT, addEvidence, addItem, addSpent, appendEvent, applyAction, assertId, assertPolicies, assignRole, authorOf, checkGate, clearBlocker, complete, coreRulesFor, createState, decide, editItem, estimateTokens, evaluatePolicies, fail, getItem, init, isExhausted, isTerminalStage, lastDispatchBefore, lastEvent, moveItem, next, nextStageOf, nowOf, openIteration, plan, raiseBlocker, raisePending, remaining, resourceCapsFor, stageOf, synthesizeBrief, toExNodes, validateAction };

package/dist/index.d.ts

@@ -0,0 +1,134 @@
+import { ErrorCode, WorkflowState, MethodologyName, Stage, Role, Event, WorkItem, Evidence, NewItem, ItemStatus, Policy, Violation, Gate, Transition, PendingHuman, Budget, Accounting, Iteration, Methodology, Brief, Handoff, ApplyResult, Rule, Action } from './types.js';
+export { Baseline, Blocker, Capability, Ceremony, CeremonyInput, ClassOfService, CoreTerm, GateRequirement, ItemType, Lesson, LessonChange, ModelTier, Phase, PlannerOptions, Verdict } from './types.js';
+export { a as approversFor, c as canDo, h as hasCapability, r as registerRole, b as requireCap, d as requireCapabilities, e as retireRole, f as rolesWith, s as separationLost } from './roles-BLBRKhUZ.js';
+import { ExNode } from 'ex-flow';
+
+interface WorkflowErrorExtra {
+    items?: string[];
+    rule?: string;
+}
+declare class WorkflowError extends Error {
+    readonly code: ErrorCode;
+    readonly fix: string;
+    readonly items?: string[];
+    readonly rule?: string;
+    constructor(code: ErrorCode, message: string, fix: string, extra?: WorkflowErrorExtra);
+    toJSON(): {
+        code: ErrorCode;
+        message: string;
+        fix: string;
+        items?: string[];
+        rule?: string;
+    };
+}
+declare function fail(code: ErrorCode, message: string, fix: string, extra?: WorkflowErrorExtra): never;
+/** Ids become object keys and file names: letters, digits, `.`, `_`, `-`; no `..`, no prototype names. */
+declare function assertId(id: unknown, what: string): void;
+
+declare function nowOf(now?: string): string;
+interface CreateStateInput {
+    methodology: MethodologyName;
+    config: unknown;
+    stages: Stage[];
+    roles: Role[];
+    now?: string;
+}
+declare function createState(input: CreateStateInput): WorkflowState;
+declare function appendEvent(state: WorkflowState, type: string, by: string, payload: unknown, now?: string): WorkflowState;
+declare function lastEvent(state: WorkflowState, type?: string): Event | undefined;
+
+declare function stageOf(state: WorkflowState, stageId: string): Stage;
+declare function nextStageOf(state: WorkflowState, stageId: string): Stage | undefined;
+declare function isTerminalStage(state: WorkflowState, stageId: string): boolean;
+declare function getItem(state: WorkflowState, id: string): WorkItem;
+declare function addItem(state: WorkflowState, input: NewItem, by: string, now?: string): WorkflowState;
+type ItemPatch = Partial<Omit<WorkItem, "id" | "stage" | "status" | "transitions" | "evidence" | "blockers">>;
+declare function editItem(state: WorkflowState, id: string, patch: ItemPatch, by: string, now?: string): WorkflowState;
+declare function moveItem(state: WorkflowState, id: string, to: {
+    stage?: string;
+    status: ItemStatus;
+}, by: string, now?: string): WorkflowState;
+declare function addEvidence(state: WorkflowState, id: string, evidence: Omit<Evidence, "at">, now?: string): WorkflowState;
+declare function raiseBlocker(state: WorkflowState, id: string, reason: string, owner: string, by: string, now?: string): WorkflowState;
+declare function clearBlocker(state: WorkflowState, id: string, blockerId: string, by: string, now?: string): WorkflowState;
+
+declare function evaluatePolicies(state: WorkflowState, item: WorkItem, policies: Policy[]): Violation[];
+declare function assertPolicies(state: WorkflowState, item: WorkItem, policies: Policy[], context: string): void;
+
+type GateResult = {
+    outcome: "pass";
+} | {
+    outcome: "human";
+} | {
+    outcome: "fail";
+    violations: Violation[];
+};
+/** Last in_progress dispatch made from a stage that comes STRICTLY BEFORE the item's current stage in `state.stages` order (unknown stage ids count as not-before). */
+declare function lastDispatchBefore(state: WorkflowState, item: WorkItem): Transition | undefined;
+/** Role that did the work the gate guards: the last dispatch made from a stage strictly before the current one (so a reviewer dispatched into the gated stage is not its author); else the last dispatch of any stage; undefined if never dispatched. */
+declare function authorOf(state: WorkflowState, item: WorkItem): string | undefined;
+declare function checkGate(state: WorkflowState, item: WorkItem, gate: Gate, by: string): GateResult;
+declare function raisePending(state: WorkflowState, pending: Omit<PendingHuman, "id" | "raisedAt">, now?: string): WorkflowState;
+declare function decide(state: WorkflowState, pendingId: string, decision: "approve" | "reject", by: string, note: string, now?: string): WorkflowState;
+
+declare const ZERO_SPENT: Required<Budget>;
+declare function addSpent(spent: Required<Budget>, acc: Accounting): Required<Budget>;
+declare function remaining(budget: Budget, spent: Required<Budget>): Budget;
+declare function isExhausted(budget: Budget, spent: Required<Budget>): boolean;
+declare function estimateTokens(state: WorkflowState, weight: number | undefined, fallbackPerWeight?: number): number;
+
+type NodeData = {
+    id: string;
+};
+declare function openIteration(state: WorkflowState): Iteration | undefined;
+declare function assignRole(state: WorkflowState, item: WorkItem): Role;
+declare function resourceCapsFor(state: WorkflowState): Record<string, number>;
+declare function toExNodes(items: WorkItem[], state: WorkflowState, priorityOf?: (item: WorkItem) => number | undefined): ExNode<NodeData>[];
+interface PlanOptions {
+    max?: number;
+    now?: string;
+    fallbackTokensPerWeight?: number;
+}
+type PlanReason = "no-candidates" | "budget-exhausted" | "wip-full" | "policy-blocked";
+/** A ready item the planner did not pull, and why. */
+interface Skipped {
+    id: string;
+    reason: "entry-policy" | "wip" | "resource-cap" | "budget";
+    detail: string;
+}
+interface PlanResult {
+    state: WorkflowState;
+    dispatched: WorkItem[];
+    skipped: Skipped[];
+    reason?: PlanReason;
+}
+declare function plan(state: WorkflowState, methodology: Methodology, opts?: PlanOptions): PlanResult;
+
+declare function synthesizeBrief(state: WorkflowState, methodology: Methodology, item: WorkItem): Brief;
+interface NextResult {
+    state: WorkflowState;
+    briefs: Brief[];
+    skipped: Skipped[];
+    reason?: PlanReason;
+}
+declare function next(state: WorkflowState, methodology: Methodology, opts?: PlanOptions): NextResult;
+
+declare function complete(state: WorkflowState, methodology: Methodology, handoff: Handoff, acc: Accounting, now?: string): ApplyResult;
+
+declare function coreRulesFor(methodology: Pick<Methodology, "requiredCapabilities">): Rule[];
+
+declare function validateAction(state: WorkflowState, methodology: Methodology, action: Action): Violation[];
+declare function applyAction(state: WorkflowState, methodology: Methodology, action: Action, reduce: (s: WorkflowState) => WorkflowState): ApplyResult;
+interface InitInput<C> {
+    methodology: Methodology<C>;
+    config: unknown;
+    roles?: Role[];
+    stages?: Stage[];
+    by?: string;
+    now?: string;
+}
+declare function init<C>(input: InitInput<C>): ApplyResult;
+
+declare const VERSION = "0.2.0-stage";
+
+export { Accounting, Action, ApplyResult, Brief, Budget, ErrorCode, Event, Evidence, Gate, type GateResult, Handoff, type InitInput, type ItemPatch, ItemStatus, Iteration, Methodology, MethodologyName, NewItem, type NextResult, PendingHuman, type PlanOptions, type PlanReason, type PlanResult, Policy, Role, Rule, type Skipped, Stage, Transition, VERSION, Violation, WorkItem, WorkflowError, WorkflowState, ZERO_SPENT, addEvidence, addItem, addSpent, appendEvent, applyAction, assertId, assertPolicies, assignRole, authorOf, checkGate, clearBlocker, complete, coreRulesFor, createState, decide, editItem, estimateTokens, evaluatePolicies, fail, getItem, init, isExhausted, isTerminalStage, lastDispatchBefore, lastEvent, moveItem, next, nextStageOf, nowOf, openIteration, plan, raiseBlocker, raisePending, remaining, resourceCapsFor, stageOf, synthesizeBrief, toExNodes, validateAction };

package/dist/index.mjs

@@ -0,0 +1,2 @@
+import'./chunk-KIQOUUEZ.mjs';export{c as complete,b as next,a as synthesizeBrief}from'./chunk-VN2UYV2O.mjs';export{a as ZERO_SPENT,b as addSpent,g as assignRole,e as estimateTokens,d as isExhausted,f as openIteration,j as plan,c as remaining,h as resourceCapsFor,i as toExNodes}from'./chunk-PD5FBDN7.mjs';export{y as addEvidence,v as addItem,c as appendEvent,M as applyAction,k as approversFor,E as assertPolicies,G as authorOf,n as canDo,H as checkGate,A as clearBlocker,K as coreRulesFor,b as createState,J as decide,w as editItem,D as evaluatePolicies,u as getItem,h as hasCapability,N as init,r as isTerminalStage,F as lastDispatchBefore,d as lastEvent,x as moveItem,q as nextStageOf,a as nowOf,z as raiseBlocker,I as raisePending,f as registerRole,o as requireCap,l as requireCapabilities,g as retireRole,i as rolesWith,m as separationLost,p as stageOf,L as validateAction}from'./chunk-NQU5TH3A.mjs';export{a as WorkflowError,c as assertId,b as fail}from'./chunk-2FRRD6A3.mjs';var U="0.2.0-stage";export{U as VERSION};//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts"],"names":["VERSION"],"mappings":"s9BAAO,IAAMA,CAAAA,CAAU","file":"index.mjs","sourcesContent":["export const VERSION = \"0.2.0-stage\";\nexport * from \"./types.ts\";\nexport { WorkflowError, fail } from \"./errors.ts\";\nexport { createState, appendEvent, lastEvent, nowOf } from \"./state.ts\";\nexport {\n  registerRole,\n  retireRole,\n  hasCapability,\n  rolesWith,\n  approversFor,\n  requireCapabilities,\n  separationLost,\n  canDo,\n  requireCap,\n} from \"./roles.ts\";\nexport {\n  assertId,\n  stageOf,\n  nextStageOf,\n  isTerminalStage,\n  getItem,\n  addItem,\n  editItem,\n  moveItem,\n  addEvidence,\n  raiseBlocker,\n  clearBlocker,\n} from \"./items.ts\";\nexport type { ItemPatch } from \"./items.ts\";\nexport { evaluatePolicies, assertPolicies } from \"./policies.ts\";\nexport { checkGate, authorOf, lastDispatchBefore, raisePending, decide } from \"./gates.ts\";\nexport type { GateResult } from \"./gates.ts\";\nexport { ZERO_SPENT, addSpent, remaining, isExhausted, estimateTokens } from \"./budget.ts\";\nexport { plan, toExNodes, assignRole, resourceCapsFor, openIteration } from \"./planner.ts\";\nexport type { PlanOptions, PlanReason, PlanResult, Skipped } from \"./planner.ts\";\nexport { synthesizeBrief, next } from \"./brief.ts\";\nexport type { NextResult } from \"./brief.ts\";\nexport { complete } from \"./complete.ts\";\nexport { coreRulesFor } from \"./rules.ts\";\nexport { applyAction, validateAction, init } from \"./methodology.ts\";\nexport type { InitInput } from \"./methodology.ts\";\n"]}

package/dist/kanban/index.cjs

@@ -0,0 +1,2 @@
+'use strict';var chunkD4HNETUL_cjs=require('../chunk-D4HNETUL.cjs');require('../chunk-JDVE7DQR.cjs'),require('../chunk-S3BXVHO7.cjs');Object.defineProperty(exports,"ACTIVE",{enumerable:true,get:function(){return chunkD4HNETUL_cjs.a}});Object.defineProperty(exports,"CADENCE_EVENT",{enumerable:true,get:function(){return chunkD4HNETUL_cjs.s}});Object.defineProperty(exports,"CLASSES",{enumerable:true,get:function(){return chunkD4HNETUL_cjs.k}});Object.defineProperty(exports,"DAY_MS",{enumerable:true,get:function(){return chunkD4HNETUL_cjs.l}});Object.defineProperty(exports,"DEFAULT_COLUMNS",{enumerable:true,get:function(){return chunkD4HNETUL_cjs.n}});Object.defineProperty(exports,"KANBAN_CADENCES",{enumerable:true,get:function(){return chunkD4HNETUL_cjs.j}});Object.defineProperty(exports,"KANBAN_VOCABULARY",{enumerable:true,get:function(){return chunkD4HNETUL_cjs.F}});Object.defineProperty(exports,"OPEN",{enumerable:true,get:function(){return chunkD4HNETUL_cjs.b}});Object.defineProperty(exports,"activeExpedites",{enumerable:true,get:function(){return chunkD4HNETUL_cjs.h}});Object.defineProperty(exports,"addedAt",{enumerable:true,get:function(){return chunkD4HNETUL_cjs.p}});Object.defineProperty(exports,"board",{enumerable:true,get:function(){return chunkD4HNETUL_cjs.r}});Object.defineProperty(exports,"byClassThenAge",{enumerable:true,get:function(){return chunkD4HNETUL_cjs.H}});Object.defineProperty(exports,"cadencesDue",{enumerable:true,get:function(){return chunkD4HNETUL_cjs.t}});Object.defineProperty(exports,"cardAge",{enumerable:true,get:function(){return chunkD4HNETUL_cjs.q}});Object.defineProperty(exports,"columnIndex",{enumerable:true,get:function(){return chunkD4HNETUL_cjs.f}});Object.defineProperty(exports,"columnStays",{enumerable:true,get:function(){return chunkD4HNETUL_cjs.w}});Object.defineProperty(exports,"commitmentColumn",{enumerable:true,get:function(){return chunkD4HNETUL_cjs.d}});Object.defineProperty(exports,"configOf",{enumerable:true,get:function(){return chunkD4HNETUL_cjs.m}});Object.defineProperty(exports,"deliveryColumn",{enumerable:true,get:function(){return chunkD4HNETUL_cjs.e}});Object.defineProperty(exports,"enteredStageAt",{enumerable:true,get:function(){return chunkD4HNETUL_cjs.i}});Object.defineProperty(exports,"kanban",{enumerable:true,get:function(){return chunkD4HNETUL_cjs.I}});Object.defineProperty(exports,"kanbanCeremonies",{enumerable:true,get:function(){return chunkD4HNETUL_cjs.B}});Object.defineProperty(exports,"kanbanMetrics",{enumerable:true,get:function(){return chunkD4HNETUL_cjs.x}});Object.defineProperty(exports,"kanbanRoles",{enumerable:true,get:function(){return chunkD4HNETUL_cjs.C}});Object.defineProperty(exports,"kanbanRules",{enumerable:true,get:function(){return chunkD4HNETUL_cjs.D}});Object.defineProperty(exports,"kanbanStages",{enumerable:true,get:function(){return chunkD4HNETUL_cjs.E}});Object.defineProperty(exports,"onBoard",{enumerable:true,get:function(){return chunkD4HNETUL_cjs.g}});Object.defineProperty(exports,"opsReport",{enumerable:true,get:function(){return chunkD4HNETUL_cjs.y}});Object.defineProperty(exports,"optionsColumn",{enumerable:true,get:function(){return chunkD4HNETUL_cjs.c}});Object.defineProperty(exports,"percentile",{enumerable:true,get:function(){return chunkD4HNETUL_cjs.v}});Object.defineProperty(exports,"priorityByClass",{enumerable:true,get:function(){return chunkD4HNETUL_cjs.G}});Object.defineProperty(exports,"replay",{enumerable:true,get:function(){return chunkD4HNETUL_cjs.u}});Object.defineProperty(exports,"riskReport",{enumerable:true,get:function(){return chunkD4HNETUL_cjs.z}});Object.defineProperty(exports,"validateKanbanConfig",{enumerable:true,get:function(){return chunkD4HNETUL_cjs.o}});Object.defineProperty(exports,"wantItems",{enumerable:true,get:function(){return chunkD4HNETUL_cjs.A}});//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map

package/dist/kanban/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"index.cjs"}

package/dist/kanban/index.d.cts

@@ -0,0 +1,225 @@
+import { ClassOfService, Policy, WorkflowState, Role, Stage, Rule, Methodology, Ceremony, CeremonyInput, ItemStatus, WorkItem, Event, CoreTerm } from '../types.cjs';
+
+type KanbanCadence = "replenishment" | "delivery-planning" | "service-delivery-review" | "operations-review" | "risk-review" | "strategy-review";
+declare const KANBAN_CADENCES: readonly KanbanCadence[];
+declare const CLASSES: readonly ClassOfService[];
+declare const DAY_MS = 86400000;
+interface KanbanColumn {
+    id: string;
+    name: string;
+    wipLimit?: number;
+    /** Explicit policies a card must satisfy before it LEAVES the column (checked by complete()). */
+    policies: Policy[];
+    commitmentPoint?: boolean;
+    deliveryPoint?: boolean;
+    /** Cards entering this column wait for a reviewer (status "review"). */
+    review?: boolean;
+}
+interface ServiceLevel {
+    percentile: number;
+    targetMs: number;
+}
+interface ClassConfig {
+    wipBypass?: number;
+    sle?: ServiceLevel;
+}
+interface KanbanConfig {
+    columns: KanbanColumn[];
+    classesOfService: Partial<Record<ClassOfService, ClassConfig>>;
+    fairness: {
+        aging: boolean;
+        maxDeferralRounds: number;
+    };
+    cadences: Partial<Record<KanbanCadence, {
+        everyTurns?: number;
+    }>>;
+    throughputWindowMs: number;
+    maxExpedite: number;
+}
+declare function configOf(state: WorkflowState): KanbanConfig;
+declare const DEFAULT_COLUMNS: KanbanColumn[];
+declare function validateKanbanConfig(raw: unknown): KanbanConfig;
+
+declare function kanbanRoles(): Role[];
+
+declare function kanbanStages(config: KanbanConfig): Stage[];
+
+declare function kanbanRules(): Rule[];
+
+/** input.items as a non-empty, duplicate-free string[] of existing item ids. */
+declare function wantItems(state: WorkflowState, input: CeremonyInput, cadence: string): string[];
+declare function kanbanCeremonies(methodology: () => Methodology): Record<string, Ceremony>;
+
+/** Statuses that hold a WIP slot. */
+declare const ACTIVE: ReadonlySet<ItemStatus>;
+/** Every status but done and dropped: the cards on the board. */
+declare const OPEN: ReadonlySet<ItemStatus>;
+declare function optionsColumn(state: WorkflowState): Stage;
+declare function commitmentColumn(state: WorkflowState): Stage;
+declare function deliveryColumn(state: WorkflowState): Stage;
+declare function columnIndex(state: WorkflowState, stageId: string): number;
+/** Committed and not yet delivered: column index in [commitment, delivery). */
+declare function onBoard(state: WorkflowState, item: WorkItem): boolean;
+declare function activeExpedites(state: WorkflowState): string[];
+/** ISO time the item last entered its current column; undefined when it was added there and never moved. */
+declare function enteredStageAt(item: WorkItem): string | undefined;
+
+interface BoardCard {
+    id: string;
+    title: string;
+    type: string;
+    status: ItemStatus;
+    classOfService: string;
+    role: string | null;
+    ageMs: number;
+    blocked: boolean;
+    deadline: string | null;
+}
+interface BoardColumn {
+    id: string;
+    name: string;
+    wipLimit: number | null;
+    active: number;
+    queued: number;
+    overLimit: boolean;
+    commitmentPoint: boolean;
+    deliveryPoint: boolean;
+    cards: BoardCard[];
+}
+/** Time the item was added (its item.added event), else the first event's time. */
+declare function addedAt(state: WorkflowState, id: string): string;
+declare function cardAge(state: WorkflowState, item: WorkItem, now: string): number;
+declare function board(state: WorkflowState, now: string): BoardColumn[];
+declare const CADENCE_EVENT: (c: KanbanCadence) => string;
+interface CadenceStatus {
+    cadence: KanbanCadence;
+    everyTurns: number | null;
+    lastAt: string | null;
+    turnsSince: number;
+    due: boolean;
+}
+declare function cadencesDue(state: WorkflowState): CadenceStatus[];
+
+interface OpsReport {
+    blockers: Array<{
+        item: string;
+        blocker: string;
+        owner: string;
+        reason: string;
+        ageMs: number;
+    }>;
+    agingWip: Array<{
+        item: string;
+        column: string;
+        status: string;
+        ageMs: number;
+        p85Ms: number | null;
+        overP85: boolean;
+    }>;
+    queued: Record<string, number>;
+    active: Record<string, number>;
+}
+declare function opsReport(state: WorkflowState, now: string): OpsReport;
+interface RiskReport {
+    fixedDate: Array<{
+        item: string;
+        deadline: string;
+        timeLeftMs: number;
+        projectedRemainingMs: number | null;
+        atRisk: boolean;
+    }>;
+    staleBlockers: Array<{
+        item: string;
+        blocker: string;
+        owner: string;
+        ageMs: number;
+    }>;
+    expediteActive: string[];
+}
+declare function riskReport(state: WorkflowState, now: string, staleAfterMs: number): RiskReport;
+
+interface Stay {
+    stage: string;
+    enteredAt: string;
+    leftAt?: string;
+}
+interface ReplayedItem {
+    id: string;
+    /** item type from item.added; "question" items are escalations, not deliveries */
+    type: string;
+    stage: string;
+    status: ItemStatus;
+    /** one entry per contiguous visit to a column; status changes inside a column do not end a stay */
+    stays: Stay[];
+    /** first entry into the commitment column */
+    committedAt?: string;
+    /** first entry into the delivery column */
+    deliveredAt?: string;
+    /** from the replenishment payload; "standard" when never replenished */
+    classOfService: ClassOfService;
+    deadline?: string;
+    /** closed in_progress intervals */
+    activeMs: number;
+    /** closed blocked intervals */
+    blockedMs: number;
+    /** the open status interval */
+    since: {
+        status: ItemStatus;
+        at: string;
+    };
+}
+interface ReplayedBlocker {
+    item: string;
+    blocker: string;
+    raisedAt: string;
+    clearedAt?: string;
+}
+interface Replay {
+    items: Map<string, ReplayedItem>;
+    blockers: ReplayedBlocker[];
+    /** time of the last event: the clock every "still open" measurement uses */
+    lastAt: string;
+}
+declare function replay(events: Event[], commitment: string, delivery: string): Replay;
+
+interface KanbanMetrics {
+    leadTimeMs: number[];
+    leadTimeP50: number;
+    leadTimeP85: number;
+    cycleTimeMsByColumn: Record<string, number>;
+    throughput: number[];
+    wipByColumn: Record<string, number>;
+    flowEfficiency: number;
+    agingWipMs: Record<string, number>;
+    cumulativeFlow: Record<string, number>;
+    sleCompliance: Record<string, number>;
+    blockerTimeMs: number;
+    meanBlockerTimeMs: number;
+}
+/** Nearest-rank percentile; 0 for an empty list. */
+declare function percentile(values: number[], p: number): number;
+/** Completed stay durations per column. */
+declare function columnStays(state: WorkflowState): Record<string, number[]>;
+declare function kanbanMetrics(state: WorkflowState): KanbanMetrics;
+
+declare const KANBAN_VOCABULARY: Record<CoreTerm, string>;
+
+/** What the priority function needs besides the card: how long it has been passed over, and the fairness config. */
+interface PriorityContext {
+    /** next() rounds that resolved since the card entered its column */
+    deferrals: number;
+    aging: boolean;
+    maxDeferralRounds: number;
+}
+/**
+ * Class band x 1e15 + an in-band offset. Bands: question 5, expedite 4, fixed-date 3, standard 2,
+ * intangible 1. Fixed-date: earlier deadline = larger offset. Others: own priority (clamped to +-1e9)
+ * plus, with aging, 4e9 per full window of maxDeferralRounds deferrals (priority decides within a window). An intangible card deferred that many
+ * times is scored in the standard band, so it overtakes fresh standard cards.
+ */
+declare function priorityByClass(item: WorkItem, ctx: PriorityContext): number;
+/** Class rank, then the card that has waited longest in its column, then id (FIFO by aging). */
+declare function byClassThenAge(a: WorkItem, b: WorkItem): number;
+declare function kanban(): Methodology<KanbanConfig>;
+
+export { ACTIVE, type BoardCard, type BoardColumn, CADENCE_EVENT, CLASSES, type CadenceStatus, type ClassConfig, DAY_MS, DEFAULT_COLUMNS, KANBAN_CADENCES, KANBAN_VOCABULARY, type KanbanCadence, type KanbanColumn, type KanbanConfig, type KanbanMetrics, OPEN, type OpsReport, type PriorityContext, type Replay, type ReplayedBlocker, type ReplayedItem, type RiskReport, type ServiceLevel, type Stay, activeExpedites, addedAt, board, byClassThenAge, cadencesDue, cardAge, columnIndex, columnStays, commitmentColumn, configOf, deliveryColumn, enteredStageAt, kanban, kanbanCeremonies, kanbanMetrics, kanbanRoles, kanbanRules, kanbanStages, onBoard, opsReport, optionsColumn, percentile, priorityByClass, replay, riskReport, validateKanbanConfig, wantItems };