@picked/svelte 0.0.1-dev.1789541668638 → 0.0.1-dev.1793753513002

package/dist/plugins/devtools/derive/journey-timeline/journey-timeline.d.ts

@@ -0,0 +1,70 @@
+import type { ScreenState } from '../journey-outline';
+import type { FlowEnd, TreeInput, TreeNodeKind } from '../journey-tree';
+/** Where a node leads, as the details pane lists it, loops included. */
+export interface TimelineNext {
+    to: string;
+    /** The arm's label off a decision ("Yes" or "Otherwise"), null otherwise. */
+    label: string | null;
+    arm: 'yes' | 'no' | null;
+    /** Goes back up the timeline: a loop, not drawn as a line. */
+    loop: boolean;
+}
+/** One row of the timeline. */
+export interface TimelineNode {
+    /** The graph node's own id. Every node is drawn exactly once, so it is unique. */
+    id: string;
+    kind: TreeNodeKind;
+    label: string;
+    detail: string | null;
+    rule: string | null;
+    stepKey: string | null;
+    state: ScreenState;
+    row: number;
+    lane: number;
+    /** The dot's centre in the graph column. */
+    x: number;
+    y: number;
+    /** The colour of the branch this row sits on: an index into the component's palette. */
+    colour: number;
+    next: TimelineNext[];
+    /** Hidden actions this row hands off to, where its route stops. */
+    ends: FlowEnd[];
+}
+/** One drawn line between two rows. */
+export interface TimelineEdge {
+    id: string;
+    from: string;
+    to: string;
+    arm: 'yes' | 'no' | null;
+    /** The lane the edge travels in between its two rows. */
+    lane: number;
+    /** The colour of the branch that lane carries. */
+    colour: number;
+    path: string;
+    travelled: boolean;
+}
+/** The laid-out timeline, ready to render. */
+export interface TimelineLayout {
+    nodes: TimelineNode[];
+    edges: TimelineEdge[];
+    /** How many lanes the widest row needs. */
+    lanes: number;
+    /** The graph column's width; the labels start at its right edge. */
+    width: number;
+    height: number;
+}
+/** How many branch colours the component's palette holds; a fork takes the next in turn. */
+export declare const COLOURS = 8;
+/** The height of one row. */
+export declare const ROW_HEIGHT = 34;
+/** The width of one lane. */
+export declare const LANE_WIDTH = 14;
+/**
+ * Lays an experience's flow out as a timeline. Pure: it takes the same input the tree takes.
+ *
+ * @param {TreeInput} input - The flow, its conditions, the field index and the visitor's trail.
+ * @returns {TimelineLayout} The laid-out timeline, or an empty layout for a flow with no origin.
+ * @example
+ * buildTimeline({ nodes, edges, conditions, fieldLookup, visited, currentStepKey })
+ */
+export declare function buildTimeline({ nodes, edges, conditions, fieldLookup, visited, currentStepKey, }: TreeInput): TimelineLayout;

package/dist/plugins/devtools/derive/journey-timeline/journey-timeline.js

@@ -0,0 +1 @@
+import{ARMS as e,FALLBACK as t,describeNode as n,graphStates as r,namedEnds as i,orderedOutgoing as a,withoutActions as o}from"../journey-tree/journey-tree.js";import"../journey-tree/index.js";var s=8,c=34,l=14,u=14,d={nodes:[],edges:[],lanes:0,width:0,height:0};function f(e,t,n){let r=new Map([[e,1]]),i=new Set,a=[],o=[{id:e,next:0}];for(;o.length>0;){let e=o[o.length-1],s=(t.get(e.id)??[]).filter(e=>n.has(e.destinationNodeId));if(e.next<s.length){let t=s[s.length-1-e.next];e.next+=1;let n=r.get(t.destinationNodeId);n===void 0?(r.set(t.destinationNodeId,1),o.push({id:t.destinationNodeId,next:0})):n===1&&i.add(t)}else r.set(e.id,2),a.push(e.id),o.pop()}return{order:a.toReversed(),loops:i}}function p(e){let t=e.indexOf(null);return t===-1?(e.push(null),e.length-1):t}function m(e,t,n,r,i){if(i-t<=34){let n=(t+i)/2;return`M ${e} ${t} C ${e} ${n}, ${r} ${n}, ${r} ${i}`}let a=t+34,o=i-34;return[`M ${e} ${t}`,`C ${e} ${t+17}, ${n} ${a-17}, ${n} ${a}`,`L ${n} ${o}`,`C ${n} ${o+17}, ${r} ${i-17}, ${r} ${i}`].join(` `)}function h({nodes:s,edges:c,conditions:l,fieldLookup:h,visited:g,currentStepKey:_}){let v=s.find(e=>e.type===`origin`);if(v===void 0)return d;let y=new Map(l.map(e=>[e.id,e])),b=new Map(s.map(e=>[e.id,n(e,y,h)])),x=r(b,c,g,_),S=e=>b.get(e)?.kind===`system`,{through:C,ends:w}=o(a(c),S,new Set(b.keys())),T=new Set([...b.keys()].filter(e=>!S(e))),{order:E,loops:D}=f(v.id,C,T),O=new Map(E.map((e,t)=>[e,t])),k=e=>(C.get(e)??[]).filter(e=>!D.has(e)&&O.has(e.destinationNodeId)),A=[],j=[],M=new Map,N=new Map,P=new Map,F=1,I=0,L=()=>{let e=I;return I=(I+1)%8,e};for(let e of E){let t=A.indexOf(e);t===-1&&(t=p(A),j[t]=L());for(let t=0;t<A.length;t+=1)A[t]===e&&(A[t]=null);M.set(e,t);let n=j[t]??0;for(N.set(e,n),k(e).forEach((e,r)=>{let i=r===0?t:p(A);j[i]=r===0?n:L(),A[i]=e.destinationNodeId,P.set(e,{lane:i,colour:j[i]})}),F=Math.max(F,A.length,t+1);A.length>0&&A[A.length-1]===null;)A.pop()}let R=e=>u+e*14,z=e=>e*34+17,B=E.map((n,r)=>{let a=b.get(n)??t,o=M.get(n)??0,s=(C.get(n)??[]).filter(e=>O.has(e.destinationNodeId)).map(t=>{let n=a.kind===`decision`&&t.sourceHandle!==void 0?e.get(t.sourceHandle):void 0;return{to:t.destinationNodeId,label:n?.label??null,arm:n?.arm??null,loop:D.has(t)}});return{...a,id:n,state:x.get(n)??`ahead`,row:r,lane:o,x:R(o),y:z(r),colour:N.get(n)??0,next:s,ends:i(w.get(n)??[],a,b)}}),V=new Map(B.map(e=>[e.id,e]));return{nodes:B,edges:E.flatMap(t=>k(t).flatMap(n=>{let r=V.get(t),i=V.get(n.destinationNodeId),a=P.get(n);if(r===void 0||i===void 0||a===void 0)return[];let o=r.kind===`decision`&&n.sourceHandle!==void 0?e.get(n.sourceHandle):void 0;return[{id:`${r.id}>${i.id}`,from:r.id,to:i.id,arm:o?.arm??null,lane:a.lane,colour:a.colour,path:m(r.x,r.y,R(a.lane),i.x,i.y),travelled:r.state!==`ahead`&&i.state!==`ahead`}]})),lanes:F,width:28+(F-1)*14,height:E.length*34}}export{s as COLOURS,l as LANE_WIDTH,c as ROW_HEIGHT,h as buildTimeline};

package/dist/plugins/devtools/derive/journey-tree/index.d.ts

@@ -0,0 +1,3 @@
+/** @file Public entrypoint for the flow graph to laid-out tree. */
+export { ARMS, BREADTH, DEPTH, FALLBACK, buildTree, describeNode, graphStates, namedEnds, orderedOutgoing, withoutActions, } from './journey-tree';
+export type { Described, FlowEnd, HiddenEnd, TreeInput, TreeJump, TreeLayout, TreeLink, TreeNode, TreeNodeKind, } from './journey-tree';

package/dist/plugins/devtools/derive/journey-tree/index.js

@@ -0,0 +1 @@
+export{ARMS,BREADTH,DEPTH,FALLBACK,buildTree,describeNode,graphStates,namedEnds,orderedOutgoing,withoutActions}from"./journey-tree.js";

package/dist/plugins/devtools/derive/journey-tree/journey-tree.d.ts

@@ -0,0 +1,191 @@
+import type { OutlineCondition, OutlineEdge, OutlineNode, ScreenState } from '../journey-outline';
+import type { FieldLookup } from '../plain-logic';
+/** Everything {@link buildTree} reads. The timeline reads the same input. */
+export interface TreeInput {
+    nodes: readonly OutlineNode[];
+    edges: readonly OutlineEdge[];
+    conditions: readonly OutlineCondition[];
+    fieldLookup: FieldLookup;
+    /** Step keys the visitor has entered this session. */
+    visited: ReadonlySet<string>;
+    /** The step the visitor is on right now, or null when this experience is not the open one. */
+    currentStepKey: string | null;
+}
+/** What a drawn node is, as a reviewer reads it. `system` is an action. */
+export type TreeNodeKind = 'start' | 'screen' | 'decision' | 'system' | 'journey';
+/** One laid-out dot on the map. */
+export interface TreeNode {
+    /** Unique within the tree. A reference leaf gets its own id; `nodeId` names the graph node. */
+    id: string;
+    nodeId: string;
+    kind: TreeNodeKind;
+    label: string;
+    /** The machine name behind the label: an action key, a step key, a condition key. */
+    detail: string | null;
+    /** A decision's verbatim JSON Logic. The sentence in `label` is lossy; this is what makes it safe. */
+    rule: string | null;
+    stepKey: string | null;
+    /** Read off the visited trail for screens; machinery inherits it from the screens around it. */
+    state: ScreenState;
+    /** A second arrival at a node already drawn: a rejoin or a loop. Always a leaf. */
+    reference: boolean;
+    /** Has no children: the end of a branch. A leaf is labelled below its dot, not above. */
+    leaf: boolean;
+    /** Hidden actions this node hands off to, where the route stops. Empty on a reference. */
+    ends: FlowEnd[];
+    depth: number;
+    /** The dot's centre on the canvas. */
+    x: number;
+    y: number;
+}
+/** An action a route ends on. Not drawn; named on the node that hands off to it. */
+export interface FlowEnd {
+    /** The action's graph node id. NOT unique on its node: both arms of a decision can end on one. */
+    id: string;
+    /** Unique on its node: the route it left on and the action it stopped at. Key a list on this. */
+    key: string;
+    label: string;
+    /** The decision arm's label ("Yes" or "Otherwise") when one ends here, null otherwise. */
+    armLabel: string | null;
+    arm: 'yes' | 'no' | null;
+}
+/** One drawn link between a parent dot and a child dot. */
+export interface TreeLink {
+    id: string;
+    from: string;
+    to: string;
+    /** Which arm of a decision this is, by the engine's own handle. Null off a decision. */
+    arm: 'yes' | 'no' | null;
+    /** The arm's label on a decision's arms, null everywhere else. */
+    label: string | null;
+    /** An SVG path in d3's `linkHorizontal` shape, so a link leaves and enters its dots level. */
+    path: string;
+    labelX: number;
+    labelY: number;
+    /** Both ends are on the trail the visitor has walked. */
+    travelled: boolean;
+}
+/**
+ * A reference leaf's way back to the node it names, drawn dashed, so a rejoin or a loop reads as
+ * one route on the map without breaking the tree's shape.
+ */
+export interface TreeJump {
+    /** The reference leaf's id; a leaf has exactly one way back. */
+    id: string;
+    from: string;
+    /** The node drawn in full. */
+    to: string;
+    path: string;
+    /** The target sits at or before the leaf's level: a loop, or a rejoin onto an earlier branch. */
+    back: boolean;
+}
+/** The laid-out tree, ready to render. */
+export interface TreeLayout {
+    nodes: TreeNode[];
+    links: TreeLink[];
+    jumps: TreeJump[];
+    width: number;
+    height: number;
+    /** The tree outgrew its size cap, and the deepest branches were cut short. */
+    truncated: boolean;
+}
+/** Between neighbouring dots on one level: the devtools `nodeSize` breadth, plus room for 2 lines. */
+export declare const BREADTH = 88;
+/** Between levels: the devtools `nodeSize` depth, plus room for a 30-character label. */
+export declare const DEPTH = 220;
+/**
+ * A condition's arms, as the runtime picks them by `edge.sourceHandle`. A Map, not a record: an
+ * index signature would type a miss as a hit.
+ */
+export declare const ARMS: Map<string, {
+    arm: 'yes' | 'no';
+    label: string;
+    order: number;
+}>;
+/** The reviewer-facing shape of one graph node. */
+export type Described = Pick<TreeNode, 'kind' | 'label' | 'detail' | 'rule' | 'stepKey'>;
+/** What a node id with no node behind it becomes. */
+export declare const FALLBACK: Described;
+/**
+ * The reviewer-facing shape of one node: what it is called, and what sits behind the name. An
+ * action is named by its key, so a map with several says which branch does what.
+ *
+ * @param {OutlineNode} node - The graph node.
+ * @param {ReadonlyMap<string, OutlineCondition>} conditionById - Registered conditions by id.
+ * @param {FieldLookup} fieldLookup - The field index.
+ * @returns {Described} The node's kind, label, detail, rule and step key.
+ * @example
+ * describeNode({ id: 's', type: 'step', stepKey: 'postcode' }, new Map(), () => undefined).label // 'Postcode'
+ */
+export declare function describeNode(node: OutlineNode, conditionById: ReadonlyMap<string, OutlineCondition>, fieldLookup: FieldLookup): Described;
+/**
+ * Every graph node's state. A screen reads the trail directly. Machinery is on the trail when it
+ * sits after somewhere the flow has certainly been (a seen screen, or the start) and before a
+ * screen the visitor has certainly reached, with only machinery in between.
+ *
+ * Worked on the GRAPH, not the tree: in the tree a rejoined node sits under whichever arm the walk
+ * reached first, which need not be the arm the visitor took. It UNDER-claims: an arm that leads
+ * only to screens not yet reached stays unmarked rather than guessed at.
+ *
+ * @param {ReadonlyMap<string, Described>} described - Every node's shape, by id.
+ * @param {readonly OutlineEdge[]} edges - The flow's edges.
+ * @param {ReadonlySet<string>} visited - Step keys entered this session.
+ * @param {string | null} currentStepKey - The step the visitor is on.
+ * @returns {Map<string, ScreenState>} Each node's state, by id.
+ * @example
+ * graphStates(described, edges, new Set(['postcode']), 'address')
+ */
+export declare function graphStates(described: ReadonlyMap<string, Described>, edges: readonly OutlineEdge[], visited: ReadonlySet<string>, currentStepKey: string | null): Map<string, ScreenState>;
+/**
+ * Edges out of each node in the order they read: a decision's Yes before its Otherwise,
+ * everything else as authored. A repeated edge to the same node is kept once.
+ *
+ * @param {readonly OutlineEdge[]} edges - The flow's edges.
+ * @returns {Map<string, OutlineEdge[]>} Each node's outgoing edges, in reading order.
+ * @example
+ * orderedOutgoing(edges).get('decision-1')
+ */
+export declare function orderedOutgoing(edges: readonly OutlineEdge[]): Map<string, OutlineEdge[]>;
+/** Where a route through actions stops: the edge it left on, and the action it stopped at. */
+export interface HiddenEnd {
+    edge: OutlineEdge;
+    id: string;
+}
+/**
+ * The flow with its actions taken out. Each edge into an action is followed through every action
+ * after it to the drawn nodes it reaches, and becomes an edge straight to each, carrying the
+ * handle it LEFT on, so a decision's arm stays its arm. An action with nowhere to go is an END.
+ * Takes and answers `orderedOutgoing`'s shape, so a caller swaps one for the other.
+ *
+ * @param {ReadonlyMap<string, OutlineEdge[]>} outgoing - Each node's outgoing edges.
+ * @param {(id: string) => boolean} isAction - Whether a node id is an action.
+ * @param {ReadonlySet<string>} known - The node ids that exist.
+ * @returns {{ through: Map<string, OutlineEdge[]>, ends: Map<string, HiddenEnd[]> }} The drawn edges, and each node's hidden ends.
+ * @example
+ * withoutActions(orderedOutgoing(edges), (id) => kindOf(id) === 'system', new Set(ids))
+ */
+export declare function withoutActions(outgoing: ReadonlyMap<string, OutlineEdge[]>, isAction: (id: string) => boolean, known: ReadonlySet<string>): {
+    through: Map<string, OutlineEdge[]>;
+    ends: Map<string, HiddenEnd[]>;
+};
+/**
+ * A node's hidden ends, named for a reader, with the arm they hang off.
+ *
+ * @param {readonly HiddenEnd[]} hidden - The node's hidden ends.
+ * @param {Described} from - The node they hang off.
+ * @param {ReadonlyMap<string, Described>} described - Every node's shape, by id.
+ * @returns {FlowEnd[]} The ends, ready to render.
+ * @example
+ * namedEnds(ends.get(nodeId) ?? [], shape, described)
+ */
+export declare function namedEnds(hidden: readonly HiddenEnd[], from: Described, described: ReadonlyMap<string, Described>): FlowEnd[];
+/**
+ * Lays an experience's flow out as the devtools tree. Pure: everything it needs arrives as an
+ * argument.
+ *
+ * @param {TreeInput} input - The flow, its conditions, the field index and the visitor's trail.
+ * @returns {TreeLayout} The laid-out tree, or an empty layout for a flow with no origin.
+ * @example
+ * buildTree({ nodes, edges, conditions, fieldLookup, visited, currentStepKey })
+ */
+export declare function buildTree({ nodes, edges, conditions, fieldLookup, visited, currentStepKey, }: TreeInput): TreeLayout;

package/dist/plugins/devtools/derive/journey-tree/journey-tree.js

@@ -0,0 +1 @@
+import{NODE_LABELS as e,deslug as t,screenName as n}from"../plain-language/plain-language.js";import{describeRule as r}from"../plain-logic/plain-logic.js";var i=88,a=220,o=110,s=56,c=2e3,l=new Map([[`true`,{arm:`yes`,label:`Yes`,order:0}],[`false`,{arm:`no`,label:`Otherwise`,order:1}]]),u={kind:`system`,label:e.action,detail:null,rule:null,stepKey:null};function d(e,n,i){let a=e.conditionId===void 0?void 0:n.get(e.conditionId),o=r(a?.logic,i),s=a===void 0?o:t(a.name);return{kind:`decision`,label:o===`a rule this panel can't put into words`?s:o,detail:a?.name??null,rule:JSON.stringify(a?.logic??null,null,2),stepKey:null}}function f(r,i,a){if(r.type===`origin`)return{kind:`start`,label:e.origin,detail:null,rule:null,stepKey:null};if(r.type===`step`)return{kind:`screen`,label:n(r.name,r.stepKey),detail:r.stepKey??null,rule:null,stepKey:r.stepKey??null};if(r.type===`condition`)return d(r,i,a);if(r.type===`experience`){let e=r.experienceKey??`another journey`;return{kind:`journey`,label:t(e),detail:e,rule:null,stepKey:null}}let o=r.actionKey??r.name??r.type;return{kind:`system`,label:t(o),detail:o,rule:null,stepKey:null}}function p(e,t,n){return e!==null&&e===n?`current`:e!==null&&t.has(e)?`visited`:`ahead`}function m(e,t,n){let r=new Set,i=[...e];for(let e=0;e<i.length;e+=1)for(let a of t.get(i[e])??[]){if(r.has(a))continue;let e=n.get(a);e!==void 0&&e!==`screen`&&e!==`start`&&(r.add(a),i.push(a))}return r}function h(e,t,n,r){let i=new Map,a=new Map;for(let[t,o]of e)a.set(t,o.kind),i.set(t,p(o.stepKey,n,r));let o=[...e].filter(([e,t])=>t.kind===`screen`&&i.get(e)!==`ahead`).map(([e])=>e);if(o.length===0)return i;let s=new Map,c=new Map;for(let e of t)s.set(e.sourceNodeId,[...s.get(e.sourceNodeId)??[],e.destinationNodeId]),c.set(e.destinationNodeId,[...c.get(e.destinationNodeId)??[],e.sourceNodeId]);let l=[...e].filter(([,e])=>e.kind===`start`).map(([e])=>e),u=m([...o,...l],s,a),d=m(o,c,a);for(let t of e.keys())u.has(t)&&d.has(t)&&i.set(t,`visited`);for(let e of l)i.set(e,`visited`);return i}function g(e,t,n,r){return{id:e,nodeId:t,reference:n,handle:r,parent:null,children:[],index:0,depth:0,prelim:0,mod:0,change:0,shift:0,thread:null,ancestor:null,defaultAncestor:null,x:0}}function _(e){let t=new Map;for(let n of e){let e=t.get(n.sourceNodeId)??[];e.some(e=>e.destinationNodeId===n.destinationNodeId)||(e.push(n),t.set(n.sourceNodeId,e))}let n=e=>e.sourceHandle===void 0?2:l.get(e.sourceHandle)?.order??2;for(let e of t.values())e.sort((e,t)=>n(e)-n(t));return t}function v(e,t,n,r){let i=[],a=[],o=new Set([e.destinationNodeId]),s=[e.destinationNodeId];for(let c=0;c<s.length;c+=1){let l=(t.get(s[c])??[]).filter(e=>r.has(e.destinationNodeId));l.length===0&&a.push({edge:e,id:s[c]});for(let t of l){let r=t.destinationNodeId;o.has(r)||(o.add(r),n(r)?s.push(r):i.push({...e,id:`${e.id}~${r}`,destinationNodeId:r}))}}return{out:i,ended:a}}function y(e,t,n){let r=new Map,i=new Map;for(let[a,o]of e){if(t(a))continue;let s=[],c=[];for(let r of o){if(!n.has(r.destinationNodeId))continue;if(!t(r.destinationNodeId)){s.push(r);continue}let i=v(r,e,t,n);s.push(...i.out),c.push(...i.ended)}r.set(a,s.filter((e,t)=>s.findIndex(t=>t.destinationNodeId===e.destinationNodeId)===t)),c.length>0&&i.set(a,c)}return{through:r,ends:i}}function b(e,t,n){return e.map(({edge:e,id:r})=>{let i=t.kind===`decision`&&e.sourceHandle!==void 0?l.get(e.sourceHandle):void 0;return{id:r,key:`${e.id}~${r}`,label:n.get(r)?.label??r,armLabel:i?.label??null,arm:i?.arm??null}})}function x(e,t,n,r){let i=r;for(let r of t){if(!n.has(r.destinationNodeId))continue;if(i>=c)return{count:i,cut:!0};let t=g(r.destinationNodeId,r.destinationNodeId,!1,r.sourceHandle);t.parent=e,t.index=e.children.length,t.depth=e.depth+1,e.children.push(t),i+=1}return{count:i,cut:!1}}function S(e,t,n){let r=g(e,e,!1,void 0),i=new Set,a=[r],o=1,s=!1;for(let e=a.pop();e!==void 0;e=a.pop()){if(i.has(e.nodeId)){e.reference=!0,e.id=`${e.parent?.id??``}>${e.nodeId}`;continue}i.add(e.nodeId);let r=x(e,t.get(e.nodeId)??[],n,o);o=r.count,s||=r.cut;for(let t=e.children.length-1;t>=0;--t)a.push(e.children[t])}return{root:r,truncated:s}}function C(e,t){return(e.parent===t.parent?1:2)*88}function w(e){return e.children.at(0)??e.thread}function T(e){return e.children.at(-1)??e.thread}function E(e,t,n){let r=n/(t.index-e.index);t.change-=r,t.shift+=n,e.change+=r,t.prelim+=n,t.mod+=n}function D(e){let t=0,n=0;for(let r=e.children.length-1;r>=0;--r){let i=e.children[r];i.prelim+=t,i.mod+=t,n+=i.change,t+=i.shift+n}}function O(e,t,n){let r=e.ancestor??e;return r.parent===t.parent?r:n}function k(e,t,n){if(t===null||e.parent===null)return n;let r=n,i=e,a=e,o=t,s=e.parent.children[0],c=i.mod,l=a.mod,u=o.mod,d=s.mod;for(o=T(o),i=w(i);o!==null&&i!==null;){s=w(s)??s,a=T(a)??a,a.ancestor=e;let t=o.prelim+u-i.prelim-c+C(o,i);t>0&&(E(O(o,e,r),e,t),c+=t,l+=t),u+=o.mod,c+=i.mod,d+=s.mod,l+=a.mod,o=T(o),i=w(i)}return o!==null&&T(a)===null&&(a.thread=o,a.mod+=u-l),i!==null&&w(s)===null&&(s.thread=i,s.mod+=c-d,r=e),r}function A(e,t){let n=e.parent??t,r=e.index>0?n.children[e.index-1]:null;if(e.children.length>0){D(e);let t=(e.children[0].prelim+(e.children.at(-1)?.prelim??0))/2;r===null?e.prelim=t:(e.prelim=r.prelim+C(e,r),e.mod=e.prelim-t)}else r!==null&&(e.prelim=r.prelim+C(e,r));n.defaultAncestor=k(e,r,n.defaultAncestor??n.children[0])}function j(e){let t=[e],n=[];for(let e=t.pop();e!==void 0;e=t.pop())n.push(e),t.push(...e.children);return n.reverse()}function M(e){let t=[e],n=[];for(let e=t.pop();e!==void 0;e=t.pop()){n.push(e);for(let n=e.children.length-1;n>=0;--n)t.push(e.children[n])}return n}function N(e){let t=g(``,``,!1,void 0);t.children=[e];let n=j(e);for(let e of n)A(e,t);e.mod=-e.prelim,e.x=e.prelim+e.mod;for(let e=n.length-1;e>=0;--e){let t=n[e];t.parent!==null&&(t.x=t.prelim+t.parent.mod,t.mod+=t.parent.mod)}return n}function P(e,t,n,r){let i=(e+n)/2;return`M ${e} ${t} C ${i} ${t}, ${i} ${r}, ${n} ${r}`}function F(e,t,n,r){let i=n<=e,a=i?60+(e-n)*.15:Math.max(60,(n-e)/2),o=i?n+a:n-a;return{path:`M ${e} ${t} C ${e+a} ${t}, ${o} ${r}, ${n} ${r}`,back:i}}var I={nodes:[],links:[],jumps:[],width:0,height:0,truncated:!1};function L({nodes:e,edges:t,conditions:n,fieldLookup:r,visited:i,currentStepKey:a}){let c=e.find(e=>e.type===`origin`);if(c===void 0)return I;let d=new Map(n.map(e=>[e.id,e])),p=new Map(e.map(e=>[e.id,f(e,d,r)])),m=h(p,t,i,a),g=e=>p.get(e)?.kind===`system`,{through:v,ends:x}=y(_(t),g,new Set(p.keys())),C=new Set([...p.keys()].filter(e=>!g(e))),{root:w,truncated:T}=S(c.id,v,C),E=N(w),D=1/0,O=-1/0,k=0;for(let e of E)D=Math.min(D,e.x),O=Math.max(O,e.x),k=Math.max(k,e.depth);let A=M(w),j=A.map(e=>{let t=p.get(e.nodeId)??u;return{...t,id:e.id,nodeId:e.nodeId,state:m.get(e.nodeId)??`ahead`,reference:e.reference,leaf:e.children.length===0,ends:e.reference?[]:b(x.get(e.nodeId)??[],t,p),depth:e.depth,x:o+e.depth*220,y:s+(e.x-D)}}),L=new Map(j.map(e=>[e.id,e])),R=A.flatMap(e=>{let t=e.parent===null?void 0:L.get(e.parent.id),n=L.get(e.id);if(t===void 0||n===void 0)return[];let r=t.kind===`decision`&&e.handle!==void 0?l.get(e.handle):void 0;return[{id:n.id,from:t.id,to:n.id,arm:r?.arm??null,label:r?.label??null,path:P(t.x,t.y,n.x,n.y),labelX:(t.x+n.x)/2,labelY:(t.y+n.y)/2-6,travelled:t.state!==`ahead`&&n.state!==`ahead`}]}),z=new Map(j.filter(e=>!e.reference).map(e=>[e.nodeId,e]));return{nodes:j,links:R,jumps:j.flatMap(e=>{let t=e.reference?z.get(e.nodeId):void 0;return t===void 0?[]:[{id:e.id,from:e.id,to:t.id,...F(e.x,e.y,t.x,t.y)}]}),width:220+k*220,height:112+(O-D),truncated:T}}export{l as ARMS,i as BREADTH,a as DEPTH,u as FALLBACK,L as buildTree,f as describeNode,h as graphStates,b as namedEnds,_ as orderedOutgoing,y as withoutActions};

package/dist/plugins/devtools/derive/plain-language/index.d.ts

@@ -0,0 +1,3 @@
+/** @file Public entrypoint for the review tools' vocabulary contract. */
+export { DEVELOPER_LABEL, NODE_LABELS, TAB_INTROS, TAB_LABELS, configSourceLabel, deslug, screenName, } from './plain-language';
+export type { ReviewTabId } from './plain-language';

package/dist/plugins/devtools/derive/plain-language/index.js

@@ -0,0 +1 @@
+export{DEVELOPER_LABEL,NODE_LABELS,TAB_INTROS,TAB_LABELS,configSourceLabel,deslug,screenName}from"./plain-language.js";

package/dist/plugins/devtools/derive/plain-language/plain-language.d.ts

@@ -0,0 +1,73 @@
+/**
+ * @file The review tools' vocabulary contract: Picked's nouns translated into a reviewer's.
+ *
+ * One module owns every translation, so the mapping is reviewable in one place and cannot drift
+ * into a component as a hard-coded string. The audience is a product, marketing or QA reviewer
+ * who knows the client's journey and its customers, and has no reason to learn what an
+ * experience, a field key or a bucket is. A word that only means something once you have seen the
+ * Picked dashboard does not belong on a reviewer's screen.
+ */
+/**
+ * Each node type, named the way a reviewer would describe what the journey is doing there.
+ */
+export declare const NODE_LABELS: {
+    readonly origin: 'Start';
+    readonly step: 'Screen';
+    readonly condition: 'Decision';
+    readonly action: 'Checking details';
+    readonly experience: 'Opens another journey';
+};
+/**
+ * Turns a kebab or snake key into a sentence. It is a fallback for a step whose author gave it no
+ * name, not a naming scheme.
+ *
+ * @param {string} key - The machine key to read.
+ * @returns {string} The key as a capitalised phrase, or the key untouched when nothing is left.
+ * @example
+ * deslug('signup-address') // 'Signup address'
+ */
+export declare function deslug(key: string): string;
+/**
+ * A step's display name. The authored `name` is written for a human, so it wins; a blank name
+ * falls back to a de-slugged key, which reads badly but still tells the reviewer where they are.
+ *
+ * @param {string | undefined} name - The step's authored name.
+ * @param {string | undefined} key - The step's key.
+ * @returns {string} A non-empty label for the screen.
+ * @example
+ * screenName(undefined, 'plan-comparison') // 'Plan comparison'
+ */
+export declare function screenName(name: string | undefined, key: string | undefined): string;
+/**
+ * How the config source is described. A session carrying a preview token reads UNPUBLISHED
+ * dashboard config, and a reviewer who does not know that reports a difference as a bug.
+ *
+ * @param {string | undefined} previewToken - The session's preview token, if any.
+ * @returns {string} The sentence the shell shows beside its badge.
+ * @example
+ * configSourceLabel(client.searchParams['preview-token']?.[0])
+ */
+export declare function configSourceLabel(previewToken: string | undefined): string;
+/**
+ * Each review tab's name, in tab-bar order. The guide's "Open …" buttons read these too, so a
+ * rename reaches both.
+ */
+export declare const TAB_LABELS: {
+    readonly guide: 'How to use';
+    readonly session: 'This session';
+    readonly answers: 'Answers';
+    readonly journey: 'Journey map';
+    readonly variations: 'Variations';
+};
+/** The id of one of the review tools' own tabs. */
+export type ReviewTabId = keyof typeof TAB_LABELS;
+/** The name of the sidebar section that holds the developer tools, apart from the review tabs. */
+export declare const DEVELOPER_LABEL = "Developer";
+/** The one-sentence purpose each tab leads with. Kept together so the tone stays consistent. */
+export declare const TAB_INTROS: {
+    readonly guide: 'How to use each tab. Open a tab straight from its section.';
+    readonly session: 'Where you are right now, and what you answered on each screen. Start here if something looks wrong.';
+    readonly answers: 'Every question this journey can ask, and the answers given. Change one to see what the customer would see.';
+    readonly journey: 'Every route this journey can take, with your route marked. Go back to any screen you have already visited.';
+    readonly variations: 'The variations running on this site. Force one on to review it, then copy the link to show someone else exactly what you saw.';
+};

package/dist/plugins/devtools/derive/plain-language/plain-language.js

@@ -0,0 +1 @@
+var e={origin:`Start`,step:`Screen`,condition:`Decision`,action:`Checking details`,experience:`Opens another journey`};function t(e){let t=e.replace(/[-_]+/g,` `).trim();return t.length===0?e:t.charAt(0).toUpperCase()+t.slice(1)}function n(e,n){let r=e?.trim();return r!==void 0&&r.length>0?r:n!==void 0&&n.length>0?t(n):`Untitled screen`}function r(e){return e!==void 0&&e.length>0?`Viewing unpublished changes`:`Viewing published content`}var i={guide:`How to use`,session:`This session`,answers:`Answers`,journey:`Journey map`,variations:`Variations`},a=`Developer`,o={guide:`How to use each tab. Open a tab straight from its section.`,session:`Where you are right now, and what you answered on each screen. Start here if something looks wrong.`,answers:`Every question this journey can ask, and the answers given. Change one to see what the customer would see.`,journey:`Every route this journey can take, with your route marked. Go back to any screen you have already visited.`,variations:`The variations running on this site. Force one on to review it, then copy the link to show someone else exactly what you saw.`};export{a as DEVELOPER_LABEL,e as NODE_LABELS,o as TAB_INTROS,i as TAB_LABELS,r as configSourceLabel,t as deslug,n as screenName};

package/dist/plugins/devtools/derive/plain-logic/index.d.ts

@@ -0,0 +1,3 @@
+/** @file Public entrypoint for the JSON Logic to sentence translation. */
+export { UNDESCRIBABLE, describeRule, varKeyOf } from './plain-logic';
+export type { FieldLookup, FieldSummary } from './plain-logic';

package/dist/plugins/devtools/derive/plain-logic/index.js

@@ -0,0 +1 @@
+export{UNDESCRIBABLE,describeRule,varKeyOf}from"./plain-logic.js";

package/dist/plugins/devtools/derive/plain-logic/plain-logic.d.ts

@@ -0,0 +1,48 @@
+/**
+ * @file JSON Logic rendered as a sentence a reviewer can read.
+ *
+ * The devtools tree prints a rule straight off its operators (`state = WA`) because it has no
+ * access to the field index. This module resolves `{"var":"state"}` through the registered FIELD
+ * and the literal through that field's OPTION labels, so the same rule reads "State is Western
+ * Australia".
+ *
+ * It uses a field's `name` (the short noun, "Purpose"), never its `label` (the question the
+ * customer was asked): a question embedded mid-sentence reads as nonsense. An operator it does not
+ * know degrades to {@link UNDESCRIBABLE} rather than guessing, and every caller pairs the sentence
+ * with a "Show rule" disclosure carrying the verbatim JSON, which is what makes degrading safe.
+ */
+/** The slice of a registered field this module reads. */
+export interface FieldSummary {
+    /** The short noun ("Purpose"). What a sentence is built from. */
+    name?: string;
+    /** The question the customer was asked. Used by the Answers table, not here. */
+    label?: string;
+    options?: readonly {
+        value: unknown;
+        label: string;
+    }[] | null;
+}
+/** Resolves a response key to the registered field behind it, or `undefined` when none is. */
+export type FieldLookup = (key: string) => FieldSummary | undefined;
+/** Shown when the rule uses an operator this module cannot put into words. */
+export declare const UNDESCRIBABLE = "a rule this panel can't put into words";
+/**
+ * The response key a `{"var": "…"}` node reads, with the `responses.` prefix removed.
+ *
+ * @param {unknown} rule - The node to read.
+ * @returns {string | undefined} The key, or `undefined` for anything that is not a var node.
+ * @example
+ * varKeyOf({ var: 'responses.state' }) // 'state'
+ */
+export declare function varKeyOf(rule: unknown): string | undefined;
+/**
+ * Renders a JSON Logic rule as a sentence. Never throws, and never returns an empty string: an
+ * unreadable rule still has to say something, because the row it labels is on screen either way.
+ *
+ * @param {unknown} rule - The JSON Logic rule.
+ * @param {FieldLookup} lookup - Resolves a response key to its registered field.
+ * @returns {string} The rule in words, or {@link UNDESCRIBABLE}.
+ * @example
+ * describeRule({ '==': [{ var: 'responses.state' }, 'WA'] }, lookup) // 'State is Western Australia'
+ */
+export declare function describeRule(rule: unknown, lookup: FieldLookup): string;

package/dist/plugins/devtools/derive/plain-logic/plain-logic.js

@@ -0,0 +1 @@
+var e=`a rule this panel can't put into words`,t={"==":`is`,"===":`is`,"!=":`is not`,"!==":`is not`,">":`is more than`,">=":`is at least`,"<":`is less than`,"<=":`is at most`},n=`responses.`;function r(e){return typeof e==`object`&&!!e&&!Array.isArray(e)}function i(e){if(!r(e))return;let t=Object.keys(e);return t.length===1?t[0]:void 0}function a(e){if(typeof e==`string`)return e;if(Array.isArray(e)&&typeof e[0]==`string`)return e[0]}function o(e){if(!r(e)||i(e)!==`var`)return;let t=a(e.var);if(t!==void 0)return t.startsWith(n)?t.slice(10):t}function s(e,t){let n=t(e)?.name?.trim();return n!==void 0&&n.length>0?n:e.replace(/[-_]+/g,` `)}function c(t,n,r){if(n!==void 0){let e=r(n)?.options?.find(e=>e.value===t);if(e!==void 0)return e.label}return t===null?`nothing`:t===!0?`yes`:t===!1?`no`:typeof t==`string`?t.length===0?`nothing`:t:typeof t==`number`?String(t):e}function l(e,t){return e.length<=1?e.join(``):e.length===2?`${e[0]} ${t} ${e[1]}`:`${e.slice(0,-1).join(`, `)} ${t} ${e[e.length-1]}`}function u(n,r,i){let[a,l]=r,u=o(a);return u===void 0?e:`${s(u,i)} ${t[n]} ${c(l,u,i)}`}function d(t,n){let[r,i]=t,a=o(r);if(a===void 0||!Array.isArray(i))return e;let u=i.map(e=>c(e,a,n));return`${s(a,n)} is ${l(u,`or`)}`}function f(e){return e===!0?`Always`:e===!1?`Never`:e==null?`Always`:null}function p(e){return e.includes(` is not `)?e.replace(` is not `,` is `):e.includes(` is `)?e.replace(` is `,` is not `):e.endsWith(` has an answer`)?`${e.slice(0,-14)} has no answer`:`not: ${e}`}function m(n,r,i){if(n in t)return r.length>=2?u(n,r,i):e;if(n===`and`||n===`or`)return r.length===0?e:l(r.map(e=>h(e,i)),n);if(n===`!`||n===`not`){let t=h(r[0],i);return t===`a rule this panel can't put into words`?e:p(t)}if(n===`!!`){let t=o(r[0]);return t===void 0?e:`${s(t,i)} has an answer`}return n===`in`?d(r,i):e}function h(t,n){let a=f(t);if(a!==null)return a;let c=o(t);if(c!==void 0)return`${s(c,n)} has an answer`;let l=i(t);if(l===void 0||!r(t))return e;let u=t[l];return m(l,Array.isArray(u)?u:[u],n)}export{e as UNDESCRIBABLE,h as describeRule,o as varKeyOf};

package/dist/plugins/devtools/derive/safety-posture/index.d.ts

@@ -0,0 +1,3 @@
+/** @file Public entrypoint for the session's safety posture. */
+export { derivePosture } from './safety-posture';
+export type { PostureOptions, SafetyPosture } from './safety-posture';

package/dist/plugins/devtools/derive/safety-posture/index.js

@@ -0,0 +1 @@
+export{derivePosture}from"./safety-posture.js";

package/dist/plugins/devtools/derive/safety-posture/safety-posture.d.ts

@@ -0,0 +1,43 @@
+/**
+ * @file What this session is allowed to do.
+ *
+ * The host may open the review tools on a live site (for a preview-token session, to review staged
+ * config against the real site). That session belongs to a real visitor: an edited answer or a
+ * jumped step is a corrupted customer journey, not a test. So the host decides, once, whether the
+ * session is read-only, and every panel reads the posture derived from that.
+ *
+ * The reviewer is TOLD the posture rather than meeting silently dead controls: the shell renders a
+ * badge from `label`, and each disabled control carries `reason` as its tooltip.
+ */
+/** What the review tools may do in this session, and how the shell explains it. */
+export interface SafetyPosture {
+    /** True when the session may belong to a real visitor. */
+    readonly readOnly: boolean;
+    /** Commit or clear an answer. */
+    readonly canEditAnswers: boolean;
+    /** Jump back to a screen already visited. */
+    readonly canNavigate: boolean;
+    /** Why, in the reviewer's words. `null` when nothing is withheld. */
+    readonly reason: string | null;
+    /** The environment name for the shell's badge. `null` shows no badge. */
+    readonly label: string | null;
+}
+/** The host's say on this session, read by {@link derivePosture}. */
+export interface PostureOptions {
+    /** The session may belong to a real visitor, so nothing may change it. */
+    readOnly: boolean;
+    /** The environment name the host wants on the badge. */
+    environmentLabel?: string;
+}
+/**
+ * Derives the posture from the host's read-only decision. Pure, so the policy is unit-testable
+ * without the build-time values a host reads to make that decision.
+ *
+ * @param {PostureOptions} options - The host's say on this session.
+ * @param {boolean} options.readOnly - Whether the session may belong to a real visitor.
+ * @param {string} [options.environmentLabel] - The badge text; defaults to "Live site" when read-only and to no badge otherwise.
+ * @returns {SafetyPosture} What the session may do, and why not when it may not.
+ * @example
+ * derivePosture({ readOnly: import.meta.env.PROD, environmentLabel: 'Staging' })
+ */
+export declare function derivePosture(options: PostureOptions): SafetyPosture;

package/dist/plugins/devtools/derive/safety-posture/safety-posture.js

@@ -0,0 +1 @@
+function e(e){return e.readOnly?{readOnly:!0,canEditAnswers:!1,canNavigate:!1,reason:`You're on the live site — this is read-only so a real customer's session can't be changed.`,label:e.environmentLabel??`Live site`}:{readOnly:!1,canEditAnswers:!0,canNavigate:!0,reason:null,label:e.environmentLabel??null}}export{e as derivePosture};

package/dist/plugins/devtools/derive/visited-steps/index.d.ts

@@ -0,0 +1,3 @@
+/** @file Public entrypoint for the visited-screens trail reducer. */
+export { nextTrails } from './visited-steps';
+export type { Trails, VisitedEvent } from './visited-steps';

package/dist/plugins/devtools/derive/visited-steps/index.js

@@ -0,0 +1 @@
+export{nextTrails}from"./visited-steps.js";

package/dist/plugins/devtools/derive/visited-steps/visited-steps.d.ts

@@ -0,0 +1,35 @@
+/**
+ * @file The screens this session has been through, as a REDUCER over the SDK's event bus.
+ *
+ * `experience.treeStore` is the AUTHORED graph: it says what CAN happen, never what did, so the
+ * journey map needs its own record of "you came this way". The trail is scoped per experience,
+ * because "screens I have seen" means nothing across journeys, and `experience_close` drops that
+ * journey's trail, so re-opening a journey starts clean. Session state only, never persisted: a
+ * stale trail would offer a jump back to a screen this page has never rendered.
+ *
+ * IMMUTABLE. A change answers a NEW map holding a new set; no change answers the SAME map. An
+ * effector store only updates on a new reference, and a Svelte read only re-renders on one, so
+ * this rule is what makes an event that changes nothing cost nothing.
+ */
+/** Step keys entered, per experience key, in the order they were first entered. */
+export type Trails = ReadonlyMap<string, ReadonlySet<string>>;
+/** The event shapes this reducer reads, narrowed from the client's `PayloadMap`. */
+export interface VisitedEvent {
+    type: string;
+    step?: {
+        key?: string;
+    };
+    experience?: {
+        experienceKey?: string;
+    };
+}
+/**
+ * The trail after one event.
+ *
+ * @param {Trails} trails - The trails so far.
+ * @param {VisitedEvent} event - The bus event.
+ * @returns {Trails} The next trails, or the same reference when the event changes nothing.
+ * @example
+ * createStore<Trails>(new Map()).on(client.eventBus, nextTrails)
+ */
+export declare function nextTrails(trails: Trails, event: VisitedEvent): Trails;

package/dist/plugins/devtools/derive/visited-steps/visited-steps.js

@@ -0,0 +1 @@
+function e(e,t){let n=t.experience?.experienceKey;if(n===void 0||n.length===0)return e;if(t.type===`experience_close`){if(!e.has(n))return e;let t=new Map(e);return t.delete(n),t}if(t.type!==`step_enter`)return e;let r=t.step?.key;if(r===void 0||r.length===0)return e;let i=e.get(n);return i?.has(r)===!0?e:new Map(e).set(n,new Set([...i??[],r]))}export{e as nextTrails};

package/dist/plugins/devtools/derive/walk-route/index.d.ts

@@ -0,0 +1,3 @@
+/** @file Public entrypoint for the walk-route reducer: every screen moved on from. */
+export { nextRoute } from './walk-route';
+export type { RouteEntry } from './walk-route';

package/dist/plugins/devtools/derive/walk-route/index.js

@@ -0,0 +1 @@
+export{nextRoute}from"./walk-route.js";

package/dist/plugins/devtools/derive/walk-route/walk-route.d.ts

@@ -0,0 +1,22 @@
+import type { HistoryEvent } from '../answer-history';
+/** One screen moved on from, and what the visitor gave there. */
+export interface RouteEntry {
+    journey: string;
+    screen: string;
+    /** The screen's authored name, for saying where a saved walk stops. */
+    screenName: string;
+    /** What the visitor gave on this screen; empty for a screen that asks nothing. */
+    answers: Readonly<Record<string, unknown>>;
+}
+/**
+ * The route after one event, given the responses held at that moment.
+ *
+ * @param {readonly RouteEntry[]} route - The route so far.
+ * @param {Readonly<Record<string, unknown>>} responses - The responses held at the event.
+ * @param {HistoryEvent} event - The bus event.
+ * @param {ReadonlySet<string>} [codeOwned] - Keys a screen carries only for its code.
+ * @returns {readonly RouteEntry[]} The next route, or the same reference when nothing is recorded.
+ * @example
+ * routeStore.on(bus, (route, event) => nextRoute(route, responses, event))
+ */
+export declare function nextRoute(route: readonly RouteEntry[], responses: Readonly<Record<string, unknown>>, event: HistoryEvent, codeOwned?: ReadonlySet<string>): readonly RouteEntry[];

package/dist/plugins/devtools/derive/walk-route/walk-route.js

@@ -0,0 +1 @@
+import{submittedAnswers as e}from"../answer-history/answer-history.js";function t(t,n,r,i=new Set){if(r.type!==`step_submit`)return t;let a=r.experience?.experienceKey,o=r.step?.key;if(a===void 0||o===void 0||o.length===0)return t;let s=Object.fromEntries(e(r.step?.fieldKeys??[],n,i).map(({key:e,value:t})=>[e,t])),c={journey:a,screen:o,screenName:r.step?.name??o,answers:s};return[...t,c].slice(-300)}export{t as nextRoute};

package/dist/plugins/devtools/index.d.ts

@@ -1,4 +1,7 @@
-/** @file Public entrypoint for the Svelte devtools plugin — the plugin factory and its consumer-facing types. */
+/** @file Public entrypoint for the Svelte devtools plugin — the plugin factory, session access and consumer-facing types. */
 export { svelteDevtoolsPlugin } from './plugin';
+export { getDevtoolsSession } from './session-access';
 export type * from './plugin';
-export type { CustomTool } from './customTools';
+export type * from './options';
+export type { CustomTool, CustomToolGuide, CustomToolPlacement } from './customTools';
+export type { DevtoolsSession } from './session-access';

package/dist/plugins/devtools/index.js

@@ -1 +1 @@
-import{svelteDevtoolsPlugin as e}from"./plugin.js";export{e as svelteDevtoolsPlugin};
+import{svelteDevtoolsPlugin as e}from"./plugin.js";import{getDevtoolsSession as t}from"./session-access.js";export{t as getDevtoolsSession,e as svelteDevtoolsPlugin};