@hotmeshio/long-tail 0.22.1 → 0.22.2

package/build/types/{scan-code.js → scan-code/constants.js}

@@ -1,12 +1,34 @@
 "use strict";
+/**
+ * Scan-code constants: encodings, scheme kinds, verbs, outcomes, and the
+ * template vocabulary.
+ *
+ * A scan code is a plain string from any input source (barcode scanner,
+ * RFID reader, manual entry) encoding version:category:target. The scheme
+ * (selected by the leading TWO digits, 10-99) declares which escalation
+ * metadata facet the target resolves against and how the string parses.
+ * The rule (selected by the single-digit category, 0-9) is an ordered list
+ * of condition/action steps over the escalation surface plus a fallback.
+ * Both indices are assigned automatically; operators name entries, not numbers.
+ */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SCAN_TEMPLATE_BAGS = exports.SCAN_TEMPLATE_TOKENS = exports.ACTING_IDENTITY_LABEL = exports.SCAN_PROVENANCE_KEYS = exports.SCAN_CARDINALITY = exports.SCAN_AVAILABILITY = exports.SCAN_OUTCOMES = exports.SCAN_MUTATING_VERBS = exports.SCAN_VERBS = exports.SCAN_SCHEME_KINDS = exports.SCAN_ENCODINGS = void 0;
+exports.SCAN_FILL_SEPARATOR_DEFAULT = exports.SCAN_HOLD_TTL_MAX_SECONDS = exports.SCAN_HOLD_TTL_MIN_SECONDS = exports.SCAN_HOLD_TTL_DEFAULT_SECONDS = exports.SCAN_TEMPLATE_BAGS = exports.SCAN_TEMPLATE_TOKENS = exports.ACTING_IDENTITY_LABEL = exports.SCAN_PROVENANCE_KEYS = exports.SCAN_CARDINALITY = exports.SCAN_AVAILABILITY = exports.SCAN_OUTCOMES = exports.SCAN_MUTATING_VERBS = exports.SCAN_VERBS = exports.SCAN_GRANT_SCOPES = exports.SCAN_SCHEME_KINDS = exports.GTIN_LENGTHS = exports.GTIN_CATEGORY = exports.SCAN_ENCODINGS = void 0;
 exports.SCAN_ENCODINGS = {
     /** Digits only, fixed widths — fits UPC-A/EAN/ITF labels. */
     FIXED: 'fixed',
     /** Delimiter-separated text — Code 128 / QR / DataMatrix labels. */
     DELIMITED: 'delimited',
+    /**
+     * Manufacturer barcodes (UPC-A, EAN-13, EAN-8, GTIN-14). The code carries
+     * no scheme or category; a valid check digit identifies it, the target is
+     * the 14-digit GTIN, and the scheme's single rule is category '0'.
+     */
+    GTIN: 'gtin',
 };
+/** The only rule category a GTIN scheme has: the code itself carries none. */
+exports.GTIN_CATEGORY = '0';
+/** Code lengths a GTIN scheme reads: EAN-8, UPC-A, EAN-13, GTIN-14. */
+exports.GTIN_LENGTHS = [8, 12, 13, 14];
 exports.SCAN_SCHEME_KINDS = {
     /** The ECA model: the target resolves against escalations; the rule's steps run. */
     ACTION: 'action',
@@ -17,6 +39,13 @@ exports.SCAN_SCHEME_KINDS = {
      */
     IDENTITY: 'identity',
 };
+/** How an identity scheme's grant is spent. */
+exports.SCAN_GRANT_SCOPES = {
+    /** Each mutating act spends one use. */
+    ACTION: 'action',
+    /** The first act binds the grant to the held subject; acts on it then spend nothing. */
+    SUBJECT: 'subject',
+};
 exports.SCAN_VERBS = {
     SHOW_DETAIL: 'show-detail',
     SHOW_LIST: 'show-list',
@@ -27,15 +56,23 @@ exports.SCAN_VERBS = {
     ESCALATE: 'escalate',
     CANCEL: 'cancel',
     /**
-     * Add the scanned item to an accumulator escalation. With
-     * `params.accumulate.containerFacet` the scan locates the ITEM's own row
-     * and joins it to the container that shares that facet value, writing
-     * both rows in one statement; without it the scan locates the CONTAINER
-     * and adds `params.itemKey`.
+     * Add to an accumulator escalation. Item mode (`containerFacet`): the scan
+     * locates the item's own row and joins the container sharing that facet.
+     * Subject mode (`from: 'subject'`): the held subject joins the scanned
+     * container. Into-subject (`into: 'subject'`): the held subject collects
+     * the scanned code. Otherwise the scan locates the container and adds
+     * `params.itemKey`.
      */
     ACCUMULATE: 'accumulate',
     /** Locate the row, then PRESENT its reality + the step's labeled choices. */
     PRESENT: 'present',
+    /**
+     * Locate the row and HOLD it as the station's subject: the next scans act
+     * on it. Writes nothing and spends no badge use.
+     */
+    HOLD: 'hold',
+    /** Fill one open batch slot whose key is the scanned code. */
+    FILL: 'fill',
 };
 /** Verbs that change escalation state (may carry a confirm prompt). */
 exports.SCAN_MUTATING_VERBS = [
@@ -46,6 +83,7 @@ exports.SCAN_MUTATING_VERBS = [
     exports.SCAN_VERBS.ESCALATE,
     exports.SCAN_VERBS.CANCEL,
     exports.SCAN_VERBS.ACCUMULATE,
+    exports.SCAN_VERBS.FILL,
 ];
 exports.SCAN_OUTCOMES = {
     /** A step matched and its action ran (or the located item is returned for show verbs). */
@@ -84,6 +122,16 @@ exports.SCAN_OUTCOMES = {
      * facet so the station can say "container closing, scan again".
      */
     NO_OPEN_CONTAINER: 'no_open_container',
+    /** A HOLD step located its row; the response carries the subject to hold. */
+    HELD: 'held',
+    /**
+     * The scan was understood and deliberately not acted on: the wrong
+     * container, an item the record does not expect, a row someone else holds.
+     * Nothing was written; the response carries the words to show.
+     */
+    REFUSED: 'refused',
+    /** The held subject moved on (resolved, re-parked, unreadable); scan the item again. */
+    SUBJECT_STALE: 'subject_stale',
 };
 exports.SCAN_AVAILABILITY = {
     AVAILABLE: 'available',
@@ -108,18 +156,31 @@ exports.SCAN_PROVENANCE_KEYS = {
 exports.ACTING_IDENTITY_LABEL = 'acting_identity';
 /**
  * Template tokens usable inside step params (item key, resolver payload,
- * metadata). Beyond the three scan tokens, `{claim.<facet>}` reads the
- * acting user's single live claim and `{item.<facet>}` reads the row an
- * item-mode accumulate step located; a token that cannot resolve fails the
- * step instead of writing the literal.
+ * metadata, refusal copy). `{scan.code}` is the raw code as scanned.
  */
 exports.SCAN_TEMPLATE_TOKENS = {
     TARGET: '{scan.target}',
     CATEGORY: '{scan.category}',
     SCANNED_AT: '{scan.scannedAt}',
+    CODE: '{scan.code}',
 };
-/** Facet-bag token prefixes: `{claim.orderId}`, `{item.binKey}`. */
+/**
+ * Facet-bag token prefixes. `{claim.x}` reads the actor's single live claim,
+ * `{item.x}` the row the step located, `{subject.x}` the held subject row,
+ * `{container.x}` the container a subject step located, and `{fill.x}` the
+ * batch a fill step read. A token that cannot resolve fails the step instead
+ * of writing the literal.
+ */
 exports.SCAN_TEMPLATE_BAGS = {
     CLAIM: 'claim',
     ITEM: 'item',
+    SUBJECT: 'subject',
+    CONTAINER: 'container',
+    FILL: 'fill',
 };
+/** Default seconds a held subject lives on the station. */
+exports.SCAN_HOLD_TTL_DEFAULT_SECONDS = 45;
+exports.SCAN_HOLD_TTL_MIN_SECONDS = 5;
+exports.SCAN_HOLD_TTL_MAX_SECONDS = 600;
+/** Separator between a code and its ordinal in batch keys (`<gtin>#2`). */
+exports.SCAN_FILL_SEPARATOR_DEFAULT = '#';

package/build/types/scan-code/index.d.ts

@@ -0,0 +1,3 @@
+export * from './constants';
+export type * from './rule';
+export type * from './response';

package/build/types/scan-code/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./constants"), exports);

package/build/types/scan-code/response.d.ts

@@ -0,0 +1,140 @@
+import type { ScanPresentedChoice } from '../scan-choice';
+import type { ScanOutcome, ScanVerb } from './constants';
+import type { ScanRuleFallback, ScanStepParams, ScanStepQuery } from './rule';
+export interface ParsedScanCode {
+    version: number;
+    category: string;
+    target: string;
+    /** The code as scanned, when the target was normalized from it (GTIN). */
+    raw?: string;
+}
+/**
+ * The station's pointer to the item it is holding. The client sends it
+ * back with each scan; the server re-derives everything from it and trusts
+ * nothing else about it.
+ */
+export interface ScanSubjectRef {
+    /** The raw code that established the subject (e.g. "11:0:K7Q2M9XA"). */
+    code: string;
+    /** The row the hold resolved to. */
+    escalationId: string;
+}
+/** A subject as the station shows it (HELD, and echoed while a fill continues). */
+export interface ScanHeldSubject extends ScanSubjectRef {
+    /** What the station calls it. */
+    label: string;
+    /** Where it goes, shown largest. */
+    headline?: string;
+    /** The line under the headline. */
+    subline?: string;
+    /** When the station lets it lapse (display and client timer). */
+    expiresAt: string;
+    /** The scan the station expects next. `prompt` is rendered markdown. */
+    expect?: {
+        schemes: number[];
+        prompt?: string;
+    };
+    /** Someone else holds a live claim on the row. */
+    claimedBy?: {
+        id: string;
+        displayName: string;
+    };
+}
+export interface ScanExecuteRequest {
+    code: string;
+    /** An acting-identity grant (eph:v1:acting_identity:*) — verbs run as that user. */
+    actingToken?: string;
+    /** The grant being replaced by an identity scan — best-effort revoked on mint. */
+    previousActingToken?: string;
+    /** The subject the station is holding. */
+    subject?: ScanSubjectRef;
+    /** The role the device is locked to; picks the badge policy when it holds several. */
+    stationRole?: string;
+}
+/** Action awaiting client-side confirmation (CONFIRM_REQUIRED). */
+export interface ScanPendingAction {
+    escalationId: string;
+    verb: ScanVerb;
+    prompt: string;
+    params?: ScanStepParams;
+}
+export interface ScanExecuteResponse {
+    outcome: ScanOutcome;
+    /** The parsed code, echoed for display/toasts. */
+    parsed?: ParsedScanCode;
+    /** Rule identity (name is the friendly label). */
+    rule?: {
+        schemeVersion: number;
+        category: string;
+        name: string;
+    };
+    /** Index of the step that matched. */
+    stepIndex?: number;
+    verb?: ScanVerb;
+    /** Single matched escalation (show-detail, claim, resolve, escalate, cancel outcomes). */
+    escalation?: Record<string, any>;
+    /** Multiple matches (show-list). */
+    escalations?: Record<string, any>[];
+    total?: number;
+    /** Query the client uses to build the list-page URL (show-list). */
+    listQuery?: ScanStepQuery & {
+        targetFacet: string;
+        target: string;
+    };
+    pendingAction?: ScanPendingAction;
+    fallback?: ScanRuleFallback;
+    /** The "scan your badge" screen (NOT_PRIMED, or beside withheld choices). */
+    notPrimed?: ScanRuleFallback;
+    /** The labeled choice set (CHOICES). */
+    choices?: ScanPresentedChoice[];
+    /** NO_OPEN_CONTAINER: the facet the located item names and no pending container carries. */
+    container?: {
+        facet: string;
+        value: string;
+    };
+    /** CHOICES: the step would auto-execute its single choice — only identity stopped it. */
+    autoSelect?: boolean;
+    /** The badged person (IDENTITY_PRIMED) — id lets the client recognize its own claims. */
+    actor?: {
+        id: string;
+        displayName: string;
+    };
+    /** The minted acting grant (IDENTITY_PRIMED) — eph:v1:acting_identity:<uuid>. */
+    actingToken?: string;
+    /** Display copy of the grant's expiry (the keystore enforces it). */
+    expiresAt?: string;
+    /** IDENTITY_PRIMED: the scheme's `grant_max_uses` (0 = TTL-bound). */
+    maxUses?: number;
+    /** IDENTITY_PRIMED: the scheme's grant scope. */
+    grantScope?: 'action' | 'subject';
+    /** What happened to the acting grant on this request. Present when one rode it. */
+    acting?: {
+        consumed: boolean;
+        remaining: number | null;
+        bound: boolean;
+    };
+    /** HELD, and a fill that continues: the subject the station holds now. */
+    subject?: ScanHeldSubject;
+    /** The station drops its held subject. */
+    clearSubject?: boolean;
+    /** REFUSED: what to say, and the target(s) the step expected. */
+    refusal?: {
+        markdown: string;
+        expected?: string[];
+    };
+    /** A fill: how far the batch has come. */
+    progress?: {
+        filled: number;
+        total: number;
+        remaining: number;
+    };
+    /** An executed add that found the item already in place. */
+    already?: boolean;
+    /** EXECUTED: the step's `done` copy, rendered. */
+    done?: {
+        markdown: string;
+    };
+    /** NOT_PRIMED that the client may replay once a badge primes. */
+    replayable?: boolean;
+    error?: string;
+}

package/build/types/scan-code/response.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/types/scan-code/rule.d.ts

@@ -0,0 +1,199 @@
+import type { ContainerSelector } from '../facets';
+import type { ScanChoice } from '../scan-choice';
+import type { ScanAvailability, ScanCardinality, ScanEncoding, ScanGrantScope, ScanSchemeKind, ScanVerb } from './constants';
+export interface ScanScheme {
+    version: number;
+    name: string;
+    description: string | null;
+    /**
+     * The metadata key the scanned target resolves against: an escalation
+     * metadata key for action schemes, an lt_users.metadata key (e.g.
+     * badge_id) for identity schemes.
+     */
+    target_facet: string;
+    encoding: ScanEncoding;
+    delimiter: string;
+    target_length: number | null;
+    kind: ScanSchemeKind;
+    /** Identity kind only: how long a minted acting grant lives (1–86400 s). */
+    grant_ttl_seconds: number | null;
+    /** Identity kind only: 0 = TTL-bound; n = the grant covers n acts. */
+    grant_max_uses: number;
+    /** Identity kind only: how the grant is spent (default 'action'). */
+    grant_scope: ScanGrantScope;
+    enabled: boolean;
+    created_at?: string;
+    updated_at?: string;
+}
+/** The Condition: a view over the escalation surface. */
+export interface ScanStepQuery {
+    /** Expected queue(s). Empty/absent = any role visible to the caller. */
+    roles?: string[];
+    status?: 'pending' | 'resolved' | 'cancelled';
+    availability?: ScanAvailability;
+    /** Extra metadata guards beyond the scheme's target facet. */
+    facets?: Record<string, any>;
+}
+export interface ScanStepParams {
+    /** Canned resolver payload template (resolve, accumulate). Values may use template tokens. */
+    resolverPayload?: Record<string, any>;
+    /** Metadata to merge/stamp (claim, resolve, escalate). */
+    metadata?: Record<string, any>;
+    /** Target role for escalate (a new escalation is created there). */
+    targetRole?: string;
+    /** Escalation type for the created escalation (escalate). */
+    escalationType?: string;
+    /** Description for the created escalation (escalate). */
+    description?: string;
+    /** How to close the located escalation before an escalate creates the next one. */
+    closeCurrent?: 'resolve' | 'cancel';
+    /** Claim window (claim verbs). */
+    durationMinutes?: number;
+    /** Item key template (accumulate). Defaults to `{scan.target}` where one is implied. */
+    itemKey?: string;
+    /** Accumulate verb options. */
+    accumulate?: ScanAccumulateParams;
+    /** Hold verb options. */
+    hold?: ScanHoldParams;
+    /** Fill verb options. */
+    fill?: ScanFillParams;
+}
+export interface ScanAccumulateParams {
+    /**
+     * Item-locate mode: the scanned target is the item's own escalation (found
+     * by the scheme facet); the container is the pending accumulator whose
+     * metadata carries this facet with the same value the item row holds.
+     */
+    containerFacet?: string;
+    /** Expected container queue(s); intersects with the actor's write scope. Alias of `container.roles`. */
+    containerRoles?: string[];
+    /**
+     * Which pending accumulator may be the container: types, subtypes and
+     * extra facet guards narrow the pick. Item mode and subject mode only.
+     */
+    container?: ContainerSelector & {
+        roles?: string[];
+    };
+    /** Item-locate mode: also write the item's row as the reciprocal (default true). */
+    reciprocal?: boolean;
+    /**
+     * Subject mode: the held subject is the item and the scanned code names
+     * the container. The subject's row is written as the reciprocal, so a
+     * one-slot subject completes in the same statement.
+     */
+    from?: 'subject';
+    /** Into-subject mode: the held subject's row is the accumulator; the item is the scanned code. */
+    into?: 'subject';
+}
+export interface ScanHoldParams {
+    /** Seconds the station holds the subject (5..600, default 45). */
+    ttlSeconds?: number;
+    /** What the station calls the subject. Template; default `{scan.target}`. */
+    label?: string;
+    /**
+     * Where the item goes, shown largest on the station (e.g. `{item.containerCode}`).
+     * Template; absent, the label leads.
+     */
+    headline?: string;
+    /** The line under the headline (e.g. `{item.locationName}`). Template. */
+    subline?: string;
+    /** The scan the station expects next, and the words that ask for it. */
+    expect?: {
+        schemes: number[];
+        prompt?: string;
+    };
+}
+export interface ScanFillParams {
+    /** Which row holds the batch: the held subject, or the row the scan names. */
+    into: 'subject' | 'scanned';
+    /** Batch keys are `<code><separator><n>`; a scan fills the first open key for its code. */
+    separator?: string;
+    /** Batch resolver payload (template). Default `{ scannedCode: '{scan.code}' }`. */
+    payload?: Record<string, any>;
+}
+/** A step that acts on the held subject runs only while one is held. */
+export interface ScanSubjectGate {
+    /** Scheme versions the subject must have been scanned under. */
+    schemes: number[];
+    /** A live claim on the subject by someone other than the actor. Default 'refuse'. */
+    claimedByOther?: 'refuse' | 'allow';
+    /**
+     * The held row must carry these facet values, or the step is skipped (the
+     * scan falls through to the next step). Branches one rule by the held
+     * item's state, e.g. `{ placement: 'unassigned' }`.
+     */
+    facets?: Record<string, string | number | boolean>;
+}
+/** The pre-write guard: a failed match refuses with nothing written. */
+export interface ScanMatch {
+    /** The scanned target must equal one of these (templates). */
+    target?: string[];
+    /** The located container must share each of these facets with the subject. */
+    facets?: string[];
+}
+/** What the station says when a step refuses. Markdown templates. */
+export interface ScanRefusal {
+    /** A failed match. */
+    markdown: string;
+    /** The atomic write lost a race (the container closed, the slot was taken). */
+    conflict?: string;
+    /**
+     * From-subject accumulate: the pairing held but no open container carries
+     * the scanned code. Without it the step falls through to the next one.
+     */
+    missing?: string;
+}
+export interface ScanStep {
+    query: ScanStepQuery;
+    cardinality?: ScanCardinality;
+    verb: ScanVerb;
+    /** Present = two-phase: locate, then the client confirms before the per-id action runs. */
+    confirm?: {
+        prompt: string;
+    };
+    params?: ScanStepParams;
+    /** PRESENT only: the labeled choice set rendered under the located reality. */
+    choices?: ScanChoice[];
+    /**
+     * PRESENT only: when the step holds exactly ONE confirm-less choice, the
+     * scan executes it directly instead of presenting — one scan, one action.
+     * An unsatisfied identity requirement still stops over at the badge screen.
+     */
+    autoSelectSingle?: boolean;
+    /** The step executes only under a real acting identity (badge or a write-capable login). */
+    requireActingIdentity?: boolean;
+    /** The step acts on the held subject and is skipped while none is held. */
+    subject?: ScanSubjectGate;
+    /** Checked before the write; a miss refuses. */
+    match?: ScanMatch;
+    /** Refusal copy for a failed match or a lost race. */
+    refuse?: ScanRefusal;
+    /**
+     * What the station says once the step's write lands: "Place it in
+     * **{container.containerCode}**." Markdown template; it may read the bags its
+     * refusal copy may read.
+     */
+    done?: {
+        markdown: string;
+    };
+}
+export interface ScanRuleFallback {
+    /** Markdown rendered on the fallback screen when no step matches. */
+    markdown?: string;
+    /** Optional dashboard route to land on instead of the default list. */
+    route?: string;
+}
+export interface ScanRule {
+    scheme_version: number;
+    /** Single digit, '0'–'9' (auto-assigned). */
+    category: string;
+    /** Friendly label — this is what gets printed next to the physical code. */
+    name: string;
+    steps: ScanStep[];
+    fallback: ScanRuleFallback;
+    /** The "scan your badge" screen — rendered when an acting identity is required and absent. */
+    notPrimed: ScanRuleFallback;
+    enabled: boolean;
+    created_at?: string;
+    updated_at?: string;
+}

package/build/types/scan-code/rule.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/types/startup.d.ts

@@ -2,7 +2,7 @@ import type { LoggerOptions } from 'pino';
 import type { WorkflowIconName } from './workflow-icons';
 import type { EscalationLookupRef } from './escalation';
 import type { LTAuthAdapter, LTSSOConfig } from './auth';
-import type { ScanEncoding, ScanSchemeKind, ScanStep, ScanRuleFallback } from './scan-code';
+import type { ScanEncoding, ScanGrantScope, ScanSchemeKind, ScanStep, ScanRuleFallback } from './scan-code';
 import type { LTOAuthStartConfig } from './oauth';
 import type { LTTelemetryAdapter } from './telemetry';
 import type { LTEventAdapter } from './events';
@@ -289,6 +289,8 @@ export interface LTScanSchemeConfig {
     kind?: ScanSchemeKind;
     grant_ttl_seconds?: number | null;
     grant_max_uses?: number;
+    /** Identity kind: 'action' (default) spends a use per act; 'subject' binds to one held subject. */
+    grant_scope?: ScanGrantScope;
     enabled?: boolean;
     /** The scheme's rules, one per category. */
     rules?: LTScanRuleConfig[];

package/dashboard/dist/assets/{AdminDashboard-BbWve-Ax.js → AdminDashboard-DBW12qQt.js}

@@ -1,2 +1,2 @@
-import{j as o}from"./vendor-query-DvWWuNIB.js";import{c as n}from"./tasks-BlpDsWCy.js";import{z as m,a9 as c}from"./index-N71QQ3J5.js";import{u}from"./mcp-Bb5psC61.js";import{P as d}from"./PageHeaderWithStats-DHj8Mqox.js";import"./vendor-react-_9U4mKFr.js";import"./vendor-icons-CeVtUKyP.js";function S(){var e;m();const{data:t}=n({limit:1}),{data:a}=c({status:"pending",limit:1}),{data:s}=u(),l=((e=s==null?void 0:s.servers)==null?void 0:e.filter(i=>i.status==="connected").length)??0,r=s?`${l}/${s.total}`:"—";return o.jsx("div",{children:o.jsx(d,{title:"Admin",stats:[{label:"Tasks",value:(t==null?void 0:t.total)??"—"},{label:"Pending Escalations",value:(a==null?void 0:a.total)??"—",dotClass:"bg-status-pending"},{label:"MCP Servers",value:r},{label:"System",value:"Healthy",dotClass:"bg-status-success"}]})})}export{S as AdminDashboard};
-//# sourceMappingURL=AdminDashboard-BbWve-Ax.js.map
+import{j as o}from"./vendor-query-DvWWuNIB.js";import{c as n}from"./tasks-La_-WAUn.js";import{z as m,a9 as c}from"./index-BQeHJHYN.js";import{u}from"./mcp-vLIutbnc.js";import{P as d}from"./PageHeaderWithStats-DHj8Mqox.js";import"./vendor-react-_9U4mKFr.js";import"./vendor-icons-CeVtUKyP.js";function S(){var e;m();const{data:t}=n({limit:1}),{data:a}=c({status:"pending",limit:1}),{data:s}=u(),l=((e=s==null?void 0:s.servers)==null?void 0:e.filter(i=>i.status==="connected").length)??0,r=s?`${l}/${s.total}`:"—";return o.jsx("div",{children:o.jsx(d,{title:"Admin",stats:[{label:"Tasks",value:(t==null?void 0:t.total)??"—"},{label:"Pending Escalations",value:(a==null?void 0:a.total)??"—",dotClass:"bg-status-pending"},{label:"MCP Servers",value:r},{label:"System",value:"Healthy",dotClass:"bg-status-success"}]})})}export{S as AdminDashboard};
+//# sourceMappingURL=AdminDashboard-DBW12qQt.js.map

package/dashboard/dist/assets/{AdminDashboard-BbWve-Ax.js.map → AdminDashboard-DBW12qQt.js.map}

@@ -1 +1 @@
-{"version":3,"file":"AdminDashboard-BbWve-Ax.js","sources":["../../src/pages/admin/AdminDashboard.tsx"],"sourcesContent":["import { useTasks } from '../../api/tasks';\nimport { useEscalations } from '../../api/escalations';\nimport { useEscalationListEvents } from '../../hooks/useEventHooks';\nimport { useMcpServers } from '../../api/mcp';\nimport { PageHeaderWithStats } from '../../components/common/layout/PageHeaderWithStats';\n\nexport function AdminDashboard() {\n  useEscalationListEvents();\n  const { data: taskData } = useTasks({ limit: 1 });\n  const { data: pendingEsc } = useEscalations({ status: 'pending', limit: 1 });\n  const { data: mcpData } = useMcpServers();\n\n  const connectedServers =\n    mcpData?.servers?.filter((s) => s.status === 'connected').length ?? 0;\n  const mcpLabel = mcpData ? `${connectedServers}/${mcpData.total}` : '—';\n\n  return (\n    <div>\n      <PageHeaderWithStats\n        title=\"Admin\"\n        stats={[\n          { label: 'Tasks', value: taskData?.total ?? '—' },\n          { label: 'Pending Escalations', value: pendingEsc?.total ?? '—', dotClass: 'bg-status-pending' },\n          { label: 'MCP Servers', value: mcpLabel },\n          { label: 'System', value: 'Healthy', dotClass: 'bg-status-success' },\n        ]}\n      />\n    </div>\n  );\n}\n"],"names":["AdminDashboard","useEscalationListEvents","taskData","useTasks","pendingEsc","useEscalations","mcpData","useMcpServers","connectedServers","_a","s","mcpLabel","jsx","PageHeaderWithStats"],"mappings":"oSAMO,SAASA,GAAiB,OAC/BC,EAAA,EACA,KAAM,CAAE,KAAMC,CAAA,EAAaC,EAAS,CAAE,MAAO,EAAG,EAC1C,CAAE,KAAMC,CAAA,EAAeC,EAAe,CAAE,OAAQ,UAAW,MAAO,EAAG,EACrE,CAAE,KAAMC,CAAA,EAAYC,EAAA,EAEpBC,IACJC,EAAAH,GAAA,YAAAA,EAAS,UAAT,YAAAG,EAAkB,OAAQC,GAAMA,EAAE,SAAW,aAAa,SAAU,EAChEC,EAAWL,EAAU,GAAGE,CAAgB,IAAIF,EAAQ,KAAK,GAAK,IAEpE,aACG,MAAA,CACC,SAAAM,EAAAA,IAACC,EAAA,CACC,MAAM,QACN,MAAO,CACL,CAAE,MAAO,QAAS,OAAOX,GAAA,YAAAA,EAAU,QAAS,GAAA,EAC5C,CAAE,MAAO,sBAAuB,OAAOE,GAAA,YAAAA,EAAY,QAAS,IAAK,SAAU,mBAAA,EAC3E,CAAE,MAAO,cAAe,MAAOO,CAAA,EAC/B,CAAE,MAAO,SAAU,MAAO,UAAW,SAAU,mBAAA,CAAoB,CACrE,CAAA,EAEJ,CAEJ"}
+{"version":3,"file":"AdminDashboard-DBW12qQt.js","sources":["../../src/pages/admin/AdminDashboard.tsx"],"sourcesContent":["import { useTasks } from '../../api/tasks';\nimport { useEscalations } from '../../api/escalations';\nimport { useEscalationListEvents } from '../../hooks/useEventHooks';\nimport { useMcpServers } from '../../api/mcp';\nimport { PageHeaderWithStats } from '../../components/common/layout/PageHeaderWithStats';\n\nexport function AdminDashboard() {\n  useEscalationListEvents();\n  const { data: taskData } = useTasks({ limit: 1 });\n  const { data: pendingEsc } = useEscalations({ status: 'pending', limit: 1 });\n  const { data: mcpData } = useMcpServers();\n\n  const connectedServers =\n    mcpData?.servers?.filter((s) => s.status === 'connected').length ?? 0;\n  const mcpLabel = mcpData ? `${connectedServers}/${mcpData.total}` : '—';\n\n  return (\n    <div>\n      <PageHeaderWithStats\n        title=\"Admin\"\n        stats={[\n          { label: 'Tasks', value: taskData?.total ?? '—' },\n          { label: 'Pending Escalations', value: pendingEsc?.total ?? '—', dotClass: 'bg-status-pending' },\n          { label: 'MCP Servers', value: mcpLabel },\n          { label: 'System', value: 'Healthy', dotClass: 'bg-status-success' },\n        ]}\n      />\n    </div>\n  );\n}\n"],"names":["AdminDashboard","useEscalationListEvents","taskData","useTasks","pendingEsc","useEscalations","mcpData","useMcpServers","connectedServers","_a","s","mcpLabel","jsx","PageHeaderWithStats"],"mappings":"oSAMO,SAASA,GAAiB,OAC/BC,EAAA,EACA,KAAM,CAAE,KAAMC,CAAA,EAAaC,EAAS,CAAE,MAAO,EAAG,EAC1C,CAAE,KAAMC,CAAA,EAAeC,EAAe,CAAE,OAAQ,UAAW,MAAO,EAAG,EACrE,CAAE,KAAMC,CAAA,EAAYC,EAAA,EAEpBC,IACJC,EAAAH,GAAA,YAAAA,EAAS,UAAT,YAAAG,EAAkB,OAAQC,GAAMA,EAAE,SAAW,aAAa,SAAU,EAChEC,EAAWL,EAAU,GAAGE,CAAgB,IAAIF,EAAQ,KAAK,GAAK,IAEpE,aACG,MAAA,CACC,SAAAM,EAAAA,IAACC,EAAA,CACC,MAAM,QACN,MAAO,CACL,CAAE,MAAO,QAAS,OAAOX,GAAA,YAAAA,EAAU,QAAS,GAAA,EAC5C,CAAE,MAAO,sBAAuB,OAAOE,GAAA,YAAAA,EAAY,QAAS,IAAK,SAAU,mBAAA,EAC3E,CAAE,MAAO,cAAe,MAAOO,CAAA,EAC/B,CAAE,MAAO,SAAU,MAAO,UAAW,SAAU,mBAAA,CAAoB,CACrE,CAAA,EAEJ,CAEJ"}