@hotmeshio/long-tail 0.30.5 → 0.31.1

package/build/shared/labels/symbol.js

@@ -0,0 +1,74 @@
+"use strict";
+// Barcode encoding: the one module that knows bwip-js. Renderers draw the
+// dark modules this returns; ZPL uses the printer's own encoder instead.
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SymbolEncodeError = void 0;
+exports.quietZoneModules = quietZoneModules;
+exports.encodeSymbol = encodeSymbol;
+const bwip_js_1 = __importDefault(require("bwip-js"));
+/** Data the symbology cannot carry. The message never repeats the data. */
+class SymbolEncodeError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'SymbolEncodeError';
+    }
+}
+exports.SymbolEncodeError = SymbolEncodeError;
+const BCID = { code128: 'code128', qrcode: 'qrcode', datamatrix: 'datamatrix' };
+const QUIET_ZONE = { code128: 10, qrcode: 4, datamatrix: 1 };
+const PRINTABLE_ASCII = /^[\x20-\x7e]+$/;
+/** The blank margin, in modules, a scanner needs around the symbol. */
+function quietZoneModules(symbology) {
+    return QUIET_ZONE[symbology];
+}
+function linearPath(sbs) {
+    let x = 0;
+    const bars = [];
+    sbs.forEach((run, i) => {
+        if (i % 2 === 0)
+            bars.push(`M${x} 0h${run}v1h-${run}z`);
+        x += run;
+    });
+    return { path: bars.join(''), width: x };
+}
+function matrixPath(raw) {
+    const rows = [];
+    for (let y = 0; y < raw.pixy; y++) {
+        let x = 0;
+        while (x < raw.pixx) {
+            if (!raw.pixs[y * raw.pixx + x]) {
+                x++;
+                continue;
+            }
+            const start = x;
+            while (x < raw.pixx && raw.pixs[y * raw.pixx + x])
+                x++;
+            rows.push(`M${start} ${y}h${x - start}v1h-${x - start}z`);
+        }
+    }
+    return rows.join('');
+}
+/** Encode `data` in `symbology`; throws SymbolEncodeError when it cannot be carried. */
+function encodeSymbol(symbology, data) {
+    if (!data)
+        throw new SymbolEncodeError('a code is empty');
+    if (symbology === 'code128' && !PRINTABLE_ASCII.test(data)) {
+        throw new SymbolEncodeError('Code 128 carries printable ASCII only');
+    }
+    let raw;
+    try {
+        raw = bwip_js_1.default.raw(BCID[symbology], data, {});
+    }
+    catch {
+        throw new SymbolEncodeError(`a code cannot be encoded as ${symbology}`);
+    }
+    const first = raw[0];
+    if ('sbs' in first) {
+        const { path, width } = linearPath(first.sbs);
+        return { path, widthModules: width, heightModules: 1 };
+    }
+    return { path: matrixPath(first), widthModules: first.pixx, heightModules: first.pixy };
+}

package/build/shared/labels/tokens.d.ts

@@ -0,0 +1,18 @@
+export interface LabelTokenContext {
+    target: string;
+    /** The row's metadata (action schemes) or a pasted list's columns. */
+    item?: Record<string, unknown>;
+    /** The identity scheme's user: name, display_name, email, roles, and metadata keys. */
+    user?: Record<string, unknown>;
+    scheme?: {
+        name: string;
+    };
+}
+/** Render one line of label text. */
+export declare function renderLabelText(template: string, ctx: LabelTokenContext): string;
+/** Every token a line uses, valid or not, without braces. */
+export declare function listLabelTokens(template: string): string[];
+/** Tokens in a line that renderLabelText does not know. */
+export declare function unknownLabelTokens(template: string): string[];
+/** `user.<key>` tokens a line uses, as keys. */
+export declare function userTokenKeys(template: string): string[];

package/build/shared/labels/tokens.js

@@ -0,0 +1,43 @@
+"use strict";
+// Label text tokens: {target}, {item.<facet>}, {user.<key>}, {scheme.name}.
+// A missing value renders empty; template validation names unknown tokens.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderLabelText = renderLabelText;
+exports.listLabelTokens = listLabelTokens;
+exports.unknownLabelTokens = unknownLabelTokens;
+exports.userTokenKeys = userTokenKeys;
+const TOKEN = /\{(target|scheme\.name|(?:item|user)\.[a-zA-Z0-9_]+)\}/g;
+const ANY_TOKEN = /\{([^{}]*)\}/g;
+function display(value) {
+    if (value === null || value === undefined)
+        return '';
+    if (Array.isArray(value))
+        return value.map(display).filter(Boolean).join(', ');
+    if (typeof value === 'object')
+        return '';
+    return String(value);
+}
+function resolve(token, ctx) {
+    if (token === 'target')
+        return ctx.target;
+    if (token === 'scheme.name')
+        return ctx.scheme?.name;
+    const [bag, key] = token.split('.', 2);
+    return (bag === 'item' ? ctx.item : ctx.user)?.[key];
+}
+/** Render one line of label text. */
+function renderLabelText(template, ctx) {
+    return template.replace(TOKEN, (_m, token) => display(resolve(token, ctx))).trim();
+}
+/** Every token a line uses, valid or not, without braces. */
+function listLabelTokens(template) {
+    return [...template.matchAll(ANY_TOKEN)].map((m) => m[1]);
+}
+/** Tokens in a line that renderLabelText does not know. */
+function unknownLabelTokens(template) {
+    return listLabelTokens(template).filter((t) => !new RegExp(`^${TOKEN.source}$`).test(`{${t}}`));
+}
+/** `user.<key>` tokens a line uses, as keys. */
+function userTokenKeys(template) {
+    return listLabelTokens(template).filter((t) => t.startsWith('user.')).map((t) => t.slice(5));
+}

package/build/shared/labels/types.d.ts

@@ -0,0 +1,105 @@
+export declare const LABEL_SYMBOLOGIES: readonly ["code128", "qrcode", "datamatrix"];
+export type LabelSymbology = (typeof LABEL_SYMBOLOGIES)[number];
+/** How a code's caption band prints on black-only stock: filled, outlined, or bare text. */
+export declare const LABEL_TONES: readonly ["solid", "outline", "plain"];
+export type LabelTone = (typeof LABEL_TONES)[number];
+/** A sheet of labels (office printer) or a thermal roll (one label per page). */
+export interface LabelMedia {
+    id: string;
+    name: string;
+    family: 'sheet' | 'thermal';
+    pageWidthMm: number;
+    pageHeightMm: number;
+    columns: number;
+    rows: number;
+    labelWidthMm: number;
+    labelHeightMm: number;
+    marginTopMm: number;
+    marginLeftMm: number;
+    gutterXMm: number;
+    gutterYMm: number;
+    cornerRadiusMm: number;
+    /** Thermal print resolution in dots per inch. */
+    dpi?: number;
+    /** The narrowest bar or module a scanner reads reliably from this stock. */
+    minModuleMm: number;
+}
+/** One code on a label: the payload, the act it names, and its band tone. */
+export interface LabelCode {
+    code: string;
+    caption: string;
+    tone: LabelTone;
+}
+/** What one label says, before layout. A masked label draws placeholders instead of codes. */
+export interface LabelContent {
+    title?: string;
+    lines: string[];
+    codes: LabelCode[];
+    masked?: boolean;
+}
+export interface LabelTextElement {
+    kind: 'text';
+    x: number;
+    y: number;
+    w: number;
+    /** Font size in millimetres (the em box). */
+    size: number;
+    text: string;
+    weight: 'regular' | 'bold';
+    align: 'left' | 'center';
+    /** White text, printed over a solid band. */
+    inverse?: boolean;
+}
+export interface LabelRectElement {
+    kind: 'rect';
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+    /** Filled black when true; outlined with `stroke` mm otherwise. */
+    fill: boolean;
+    stroke?: number;
+}
+export interface LabelSymbolElement {
+    kind: 'symbol';
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+    symbology: LabelSymbology;
+    /** The encoded payload; empty when masked. */
+    data: string;
+    moduleMm: number;
+    /** Dark modules as an SVG path in module units; empty when masked. */
+    path: string;
+    masked?: boolean;
+}
+export type LabelElement = LabelTextElement | LabelRectElement | LabelSymbolElement;
+export interface PlacedLabel {
+    /** Position on the page, counted from 0, left to right then top to bottom. */
+    slot: number;
+    /** Index of the label in the job's input. */
+    index: number;
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+    elements: LabelElement[];
+}
+export interface LabelPage {
+    labels: PlacedLabel[];
+}
+export declare const LABEL_WARNING_KINDS: readonly ["scale", "quiet_zone", "unencodable", "unparseable", "rule_disabled", "unresolved", "overflow", "missing_token"];
+export type LabelWarningKind = (typeof LABEL_WARNING_KINDS)[number];
+export interface LabelWarning {
+    /** Index of the label in the job's input. */
+    index: number;
+    kind: LabelWarningKind;
+    detail: string;
+}
+export interface LabelSheet {
+    media: LabelMedia;
+    pages: LabelPage[];
+    cutMarks: boolean;
+    warnings: LabelWarning[];
+}

package/build/shared/labels/types.js

@@ -0,0 +1,11 @@
+"use strict";
+// Label sheet model. Pure data in millimetres: the dashboard preview, browser
+// print, PDF and ZPL all render the same LabelSheet.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LABEL_WARNING_KINDS = exports.LABEL_TONES = exports.LABEL_SYMBOLOGIES = void 0;
+exports.LABEL_SYMBOLOGIES = ['code128', 'qrcode', 'datamatrix'];
+/** How a code's caption band prints on black-only stock: filled, outlined, or bare text. */
+exports.LABEL_TONES = ['solid', 'outline', 'plain'];
+exports.LABEL_WARNING_KINDS = [
+    'scale', 'quiet_zone', 'unencodable', 'unparseable', 'rule_disabled', 'unresolved', 'overflow', 'missing_token',
+];

package/build/start/adapters.js

@@ -21,6 +21,10 @@ const features_1 = require("../modules/features");
 const search_1 = require("../modules/search");
 const branding_1 = require("../modules/branding");
 const display_1 = require("../modules/display");
+const transports_1 = require("../lib/labels/transports");
+const media_1 = require("../services/labels/media");
+const render_pdf_1 = require("../services/labels/render-pdf");
+const redact_1 = require("../services/user/redact");
 const socket_auth_1 = require("./socket-auth");
 /**
  * Register all adapters (logging, telemetry, events, maintenance,
@@ -32,6 +36,18 @@ function registerAdapters(startConfig) {
     (0, search_1.configureSearch)(startConfig.search);
     (0, branding_1.configureBranding)(startConfig.branding);
     (0, display_1.configureDisplay)(startConfig.display);
+    // Label sheets: host media first, so the default may name one.
+    if (startConfig.labels?.media)
+        (0, media_1.registerLabelMedia)(startConfig.labels.media);
+    if (startConfig.labels?.defaultMedia)
+        (0, media_1.setDefaultLabelMedia)(startConfig.labels.defaultMedia);
+    if (startConfig.labels?.font)
+        (0, render_pdf_1.registerLabelFonts)(startConfig.labels.font);
+    if (startConfig.labels?.protectIdentityKeys !== undefined)
+        (0, redact_1.setIdentityKeyProtection)(startConfig.labels.protectIdentityKeys);
+    for (const [name, transport] of Object.entries(startConfig.labels?.transports ?? {})) {
+        transports_1.labelTransportRegistry.register(name, transport);
+    }
     // Logging (register first so subsequent log calls use it)
     if (startConfig.logging?.adapter) {
         logger_1.loggerRegistry.register(startConfig.logging.adapter);

package/build/start/workers.js

@@ -102,8 +102,11 @@ async function collectWorkers(startConfig) {
     ];
     logger_1.loggerRegistry.info('[long-tail] system workflows loaded');
     if (startConfig.examples) {
-        const { exampleWorkers } = await Promise.resolve().then(() => __importStar(require('../examples')));
+        const { exampleWorkers, storageDropTransport, STORAGE_DROP_TRANSPORT } = await Promise.resolve().then(() => __importStar(require('../examples')));
         workers.push(...exampleWorkers);
+        const { labelTransportRegistry } = await Promise.resolve().then(() => __importStar(require('../lib/labels/transports')));
+        if (!labelTransportRegistry.has(STORAGE_DROP_TRANSPORT))
+            labelTransportRegistry.register(STORAGE_DROP_TRANSPORT, storageDropTransport);
         logger_1.loggerRegistry.info('[long-tail] example workflows loaded');
     }
     return { workers, builtinMcpServerFactories };
@@ -499,10 +502,11 @@ async function startWorkers(startConfig, workers, builtinMcpServerFactories) {
     // applies first — rule validation reads its kind.
     if (startConfig.scanSchemes?.length) {
         const { seedScanScheme, seedScanRule, applyScanScheme, applyScanRule, listScanSchemes, listScanRules, } = await Promise.resolve().then(() => __importStar(require('../services/scan-code')));
+        const { applyLabelTemplate, seedLabelTemplate, listLabelTemplates } = await Promise.resolve().then(() => __importStar(require('../services/labels/templates')));
         const scanReport = (0, apply_report_1.newSurfaceReport)();
         for (const scheme of startConfig.scanSchemes) {
             const codeOwned = (0, apply_report_1.ownedByCode)(scheme.reset, configSource);
-            const { rules, reset: _reset, ...schemeInput } = scheme;
+            const { rules, labels, reset: _reset, ...schemeInput } = scheme;
             try {
                 if (codeOwned) {
                     let outcome = await applyScanScheme(schemeInput);
@@ -511,6 +515,11 @@ async function startWorkers(startConfig, workers, builtinMcpServerFactories) {
                         if (ruleOutcome === 'applied')
                             outcome = 'applied';
                     }
+                    for (const label of labels ?? []) {
+                        const labelOutcome = await applyLabelTemplate({ scheme_version: scheme.version, ...label });
+                        if (labelOutcome === 'applied')
+                            outcome = 'applied';
+                    }
                     (0, apply_report_1.recordOutcome)(scanReport, `scheme ${scheme.version}`, outcome);
                     if (outcome === 'applied')
                         logger_1.loggerRegistry.info(`[long-tail] scan scheme applied: ${scheme.version}`);
@@ -519,12 +528,19 @@ async function startWorkers(startConfig, workers, builtinMcpServerFactories) {
                     scanReport.orphans.push(...existingRules
                         .filter((r) => !declaredCategories.has(r.category))
                         .map((r) => `${scheme.version}/${r.category}`));
+                    const declaredLabels = new Set((labels ?? []).map((l) => l.name));
+                    scanReport.orphans.push(...(await listLabelTemplates(scheme.version))
+                        .filter((t) => !declaredLabels.has(t.name))
+                        .map((t) => `${scheme.version}/label:${t.name}`));
                 }
                 else {
                     const inserted = await seedScanScheme(schemeInput);
                     for (const rule of rules ?? []) {
                         await seedScanRule({ scheme_version: scheme.version, ...rule });
                     }
+                    for (const label of labels ?? []) {
+                        await seedLabelTemplate({ scheme_version: scheme.version, ...label });
+                    }
                     (0, apply_report_1.recordOutcome)(scanReport, `scheme ${scheme.version}`, 'db-owned');
                     if (inserted)
                         logger_1.loggerRegistry.info(`[long-tail] scan scheme seeded: ${scheme.version}`);

package/build/system/mcp-servers/admin/index.js

@@ -60,6 +60,7 @@ const exports_1 = require("./exports");
 const overview_1 = require("./overview");
 const diagnostics_1 = require("./diagnostics");
 const scan_codes_1 = require("./scan-codes");
+const labels_1 = require("./labels");
 const domain_context_1 = require("./domain-context");
 const announcements_1 = require("./announcements");
 let server = null;
@@ -91,6 +92,7 @@ async function createAdminServer(options) {
     (0, overview_1.registerOverviewTools)(instance);
     (0, diagnostics_1.registerDiagnosticsTools)(instance);
     (0, scan_codes_1.registerScanCodeTools)(instance);
+    (0, labels_1.registerLabelTools)(instance);
     (0, domain_context_1.registerDomainContextTools)(instance);
     (0, announcements_1.registerAnnouncementTools)(instance);
     logger_1.loggerRegistry.info(`[lt-mcp:admin] ${name} ready (${(0, registered_tools_1.registeredToolCount)(instance)} tools registered)`);

package/build/system/mcp-servers/admin/labels-schemas.d.ts

@@ -0,0 +1,192 @@
+import { z } from 'zod';
+export declare const listLabelTemplatesSchema: z.ZodObject<{
+    scheme: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    scheme?: number | undefined;
+}, {
+    scheme?: number | undefined;
+}>;
+export declare const upsertLabelTemplateSchema: z.ZodObject<{
+    name: z.ZodString;
+    scheme_version: z.ZodNumber;
+    title: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    codes: z.ZodArray<z.ZodObject<{
+        category: z.ZodString;
+        caption: z.ZodOptional<z.ZodString>;
+        tone: z.ZodEnum<["solid", "outline", "plain"]>;
+    }, "strip", z.ZodTypeAny, {
+        category: string;
+        tone: "solid" | "outline" | "plain";
+        caption?: string | undefined;
+    }, {
+        category: string;
+        tone: "solid" | "outline" | "plain";
+        caption?: string | undefined;
+    }>, "many">;
+    text: z.ZodOptional<z.ZodObject<{
+        title: z.ZodOptional<z.ZodString>;
+        lines: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        title?: string | undefined;
+        lines?: string[] | undefined;
+    }, {
+        title?: string | undefined;
+        lines?: string[] | undefined;
+    }>>;
+    symbology: z.ZodOptional<z.ZodEnum<["code128", "qrcode", "datamatrix"]>>;
+    human_readable: z.ZodOptional<z.ZodBoolean>;
+    media: z.ZodOptional<z.ZodString>;
+    sensitive: z.ZodOptional<z.ZodBoolean>;
+    enabled: z.ZodOptional<z.ZodBoolean>;
+    expected_revision: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    scheme_version: number;
+    title: string;
+    codes: {
+        category: string;
+        tone: "solid" | "outline" | "plain";
+        caption?: string | undefined;
+    }[];
+    enabled?: boolean | undefined;
+    text?: {
+        title?: string | undefined;
+        lines?: string[] | undefined;
+    } | undefined;
+    description?: string | undefined;
+    symbology?: "code128" | "qrcode" | "datamatrix" | undefined;
+    human_readable?: boolean | undefined;
+    media?: string | undefined;
+    sensitive?: boolean | undefined;
+    expected_revision?: number | undefined;
+}, {
+    name: string;
+    scheme_version: number;
+    title: string;
+    codes: {
+        category: string;
+        tone: "solid" | "outline" | "plain";
+        caption?: string | undefined;
+    }[];
+    enabled?: boolean | undefined;
+    text?: {
+        title?: string | undefined;
+        lines?: string[] | undefined;
+    } | undefined;
+    description?: string | undefined;
+    symbology?: "code128" | "qrcode" | "datamatrix" | undefined;
+    human_readable?: boolean | undefined;
+    media?: string | undefined;
+    sensitive?: boolean | undefined;
+    expected_revision?: number | undefined;
+}>;
+export declare const deleteLabelTemplateSchema: z.ZodObject<{
+    name: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+}, {
+    name: string;
+}>;
+export declare const renderLabelSheetSchema: z.ZodObject<{
+    template: z.ZodString;
+    source: z.ZodUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"list">;
+        text: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        kind: "list";
+        text: string;
+    }, {
+        kind: "list";
+        text: string;
+    }>, z.ZodObject<{
+        kind: z.ZodLiteral<"range">;
+        prefix: z.ZodOptional<z.ZodString>;
+        from: z.ZodNumber;
+        to: z.ZodNumber;
+        pad: z.ZodOptional<z.ZodNumber>;
+        suffix: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        kind: "range";
+        from: number;
+        to: number;
+        prefix?: string | undefined;
+        suffix?: string | undefined;
+        pad?: number | undefined;
+    }, {
+        kind: "range";
+        from: number;
+        to: number;
+        prefix?: string | undefined;
+        suffix?: string | undefined;
+        pad?: number | undefined;
+    }>, z.ZodObject<{
+        kind: z.ZodLiteral<"escalations">;
+        ids: z.ZodArray<z.ZodString, "many">;
+    }, "strip", z.ZodTypeAny, {
+        kind: "escalations";
+        ids: string[];
+    }, {
+        kind: "escalations";
+        ids: string[];
+    }>, z.ZodObject<{
+        kind: z.ZodLiteral<"facets">;
+        query: z.ZodRecord<z.ZodString, z.ZodAny>;
+    }, "strip", z.ZodTypeAny, {
+        kind: "facets";
+        query: Record<string, any>;
+    }, {
+        kind: "facets";
+        query: Record<string, any>;
+    }>]>;
+    media: z.ZodOptional<z.ZodString>;
+    startPosition: z.ZodOptional<z.ZodNumber>;
+    copies: z.ZodOptional<z.ZodNumber>;
+    format: z.ZodEnum<["pdf", "zpl"]>;
+}, "strip", z.ZodTypeAny, {
+    source: {
+        kind: "list";
+        text: string;
+    } | {
+        kind: "range";
+        from: number;
+        to: number;
+        prefix?: string | undefined;
+        suffix?: string | undefined;
+        pad?: number | undefined;
+    } | {
+        kind: "escalations";
+        ids: string[];
+    } | {
+        kind: "facets";
+        query: Record<string, any>;
+    };
+    format: "pdf" | "zpl";
+    template: string;
+    media?: string | undefined;
+    startPosition?: number | undefined;
+    copies?: number | undefined;
+}, {
+    source: {
+        kind: "list";
+        text: string;
+    } | {
+        kind: "range";
+        from: number;
+        to: number;
+        prefix?: string | undefined;
+        suffix?: string | undefined;
+        pad?: number | undefined;
+    } | {
+        kind: "escalations";
+        ids: string[];
+    } | {
+        kind: "facets";
+        query: Record<string, any>;
+    };
+    format: "pdf" | "zpl";
+    template: string;
+    media?: string | undefined;
+    startPosition?: number | undefined;
+    copies?: number | undefined;
+}>;

package/build/system/mcp-servers/admin/labels-schemas.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderLabelSheetSchema = exports.deleteLabelTemplateSchema = exports.upsertLabelTemplateSchema = exports.listLabelTemplatesSchema = void 0;
+const zod_1 = require("zod");
+const tone = zod_1.z.enum(['solid', 'outline', 'plain']);
+const symbology = zod_1.z.enum(['code128', 'qrcode', 'datamatrix']);
+exports.listLabelTemplatesSchema = zod_1.z.object({
+    scheme: zod_1.z.number().int().optional().describe('Only templates for this scan scheme version'),
+});
+exports.upsertLabelTemplateSchema = zod_1.z.object({
+    name: zod_1.z.string().describe('Template id: lowercase letters, digits and dashes'),
+    scheme_version: zod_1.z.number().int().describe('The scan scheme whose codes the label prints'),
+    title: zod_1.z.string().describe('Display name in pickers'),
+    description: zod_1.z.string().optional(),
+    codes: zod_1.z.array(zod_1.z.object({
+        category: zod_1.z.string().describe('A rule category of the scheme, 0-9'),
+        caption: zod_1.z.string().optional().describe('The act printed beside the code; defaults to the rule name'),
+        tone: tone.describe('Caption band: solid (filled), outline, or plain'),
+    })).min(1).max(4),
+    text: zod_1.z.object({
+        title: zod_1.z.string().optional().describe('Largest line, in label tokens: {target}, {item.<facet>}, {user.<key>}, {scheme.name}'),
+        lines: zod_1.z.array(zod_1.z.string()).max(2).optional(),
+    }).optional(),
+    symbology: symbology.optional(),
+    human_readable: zod_1.z.boolean().optional().describe('Print the code as text under the symbol'),
+    media: zod_1.z.string().optional().describe('Default media preset id, e.g. a4-l7160'),
+    sensitive: zod_1.z.boolean().optional().describe('Ask for confirmation and record subjects when printing'),
+    enabled: zod_1.z.boolean().optional(),
+    expected_revision: zod_1.z.number().int().optional().describe('Write only if the stored revision matches'),
+});
+exports.deleteLabelTemplateSchema = zod_1.z.object({
+    name: zod_1.z.string(),
+});
+exports.renderLabelSheetSchema = zod_1.z.object({
+    template: zod_1.z.string().describe('Label template name'),
+    source: zod_1.z.union([
+        zod_1.z.object({ kind: zod_1.z.literal('list'), text: zod_1.z.string().describe('One target per line; a header row starting with "target" names {item.<column>} tokens') }),
+        zod_1.z.object({ kind: zod_1.z.literal('range'), prefix: zod_1.z.string().optional(), from: zod_1.z.number().int(), to: zod_1.z.number().int(), pad: zod_1.z.number().int().optional(), suffix: zod_1.z.string().optional() }),
+        zod_1.z.object({ kind: zod_1.z.literal('escalations'), ids: zod_1.z.array(zod_1.z.string()) }),
+        zod_1.z.object({ kind: zod_1.z.literal('facets'), query: zod_1.z.record(zod_1.z.string(), zod_1.z.any()).describe('A FacetQuery: role, facets, …') }),
+    ]),
+    media: zod_1.z.string().optional().describe('Media preset id; defaults to the template media'),
+    startPosition: zod_1.z.number().int().optional(),
+    copies: zod_1.z.number().int().optional(),
+    format: zod_1.z.enum(['pdf', 'zpl']).describe('pdf for sheet stock, zpl for thermal media'),
+});

package/build/system/mcp-servers/admin/labels.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Label template and label sheet tools — mirrors routes/labels.ts
+ *
+ * render_label_sheet issues a sheet as the caller and stores it as a file
+ * with a short-lived link. It prints item labels only: identity templates
+ * (badges) are printed by people, with a confirmation, never by an agent.
+ */
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function registerLabelTools(server: McpServer): void;