@hotmeshio/long-tail 0.30.5 → 0.31.0

package/build/services/labels/issue.js

@@ -0,0 +1,181 @@
+"use strict";
+// Preview and issue label sheets. Issuing writes the ledger row before any
+// code is composed, so a print the ledger does not hold never happens.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertMayPrint = assertMayPrint;
+exports.previewLabels = previewLabels;
+exports.issueLabels = issueLabels;
+const transports_1 = require("../../lib/labels/transports");
+const capabilities_1 = require("../../modules/capabilities");
+const layout_1 = require("../../shared/labels/layout");
+const media_1 = require("../../shared/labels/media");
+const render_zpl_1 = require("../../shared/labels/render-zpl");
+const types_1 = require("../../types");
+const scan_code_1 = require("../scan-code");
+const content_1 = require("./content");
+const errors_1 = require("./errors");
+const jobs_1 = require("./jobs");
+const config_1 = require("../../modules/config");
+const media_2 = require("./media");
+const render_pdf_1 = require("./render-pdf");
+const targets_1 = require("./targets");
+const templates_1 = require("./templates");
+const verify_1 = require("./verify");
+async function load(name) {
+    const template = await (0, templates_1.getLabelTemplate)(name);
+    if (!template)
+        throw new errors_1.LabelRequestError(404, `label template "${name}" does not exist`);
+    if (!template.enabled)
+        throw new errors_1.LabelRequestError(400, `label template "${name}" is disabled`);
+    const scheme = await (0, scan_code_1.getScanScheme)(template.scheme_version);
+    if (!scheme)
+        throw new errors_1.LabelRequestError(404, `scan scheme ${template.scheme_version} does not exist`);
+    const rules = await (0, scan_code_1.listScanRules)(scheme.version);
+    return { template, scheme, rules, identity: scheme.kind === types_1.SCAN_SCHEME_KINDS.IDENTITY };
+}
+/** Identity labels need credentialIssuer; item labels need admin or role management. */
+async function assertMayPrint(identity, auth) {
+    const allowed = identity
+        ? await (0, capabilities_1.mayIssueCredentials)(auth)
+        : (await (0, capabilities_1.mayAdminister)(auth)) || (await (0, capabilities_1.mayManageRoles)(auth));
+    if (!allowed) {
+        throw new errors_1.LabelRequestError(403, identity
+            ? 'printing badges requires credential-issuer access'
+            : 'printing labels requires admin or role-management access');
+    }
+}
+function layoutSheet(loaded, contents, layout = {}) {
+    try {
+        return (0, layout_1.buildLabelSheet)({
+            media: (0, media_2.mediaForJob)(layout.media, loaded.template.media),
+            labels: contents,
+            symbology: loaded.template.symbology,
+            humanReadable: loaded.template.human_readable,
+            startPosition: layout.startPosition,
+            copies: layout.copies,
+            onePerPage: layout.onePerPage,
+            cutMarks: layout.cutMarks,
+        });
+    }
+    catch (err) {
+        if (err instanceof layout_1.LabelLayoutError || err instanceof media_1.LabelMediaError)
+            throw new errors_1.LabelRequestError(400, err.message);
+        throw err;
+    }
+}
+async function compose(loaded, targets, layout, masked) {
+    if (!loaded.identity)
+        await (0, targets_1.markResolvedTargets)(targets, loaded.scheme);
+    const built = (0, content_1.buildLabelContents)(loaded.template, loaded.scheme, loaded.rules, targets, masked);
+    const sheet = layoutSheet(loaded, built.contents, layout);
+    const verified = (0, verify_1.verifyLabels)(loaded.template, loaded.scheme, await (0, scan_code_1.listScanSchemes)(), loaded.rules, targets, built.contents);
+    const warnings = [...built.warnings, ...verified, ...sheet.warnings];
+    return { sheet: { ...sheet, warnings }, warnings };
+}
+/**
+ * Lay out a job without printing it. Sensitive templates are masked: the
+ * preview shows where each code goes, never the code. Nothing is recorded.
+ */
+async function previewLabels(req, auth) {
+    const loaded = await load(req.template);
+    await assertMayPrint(loaded.identity, auth);
+    const targets = await (0, targets_1.resolveLabelTargets)(req.source, loaded.scheme, auth);
+    const { sheet, warnings } = await compose(loaded, targets, req.layout, loaded.template.sensitive);
+    return { template: loaded.template, sheet, warnings, labelCount: targets.length };
+}
+function transportFor(output, format) {
+    const name = output.slice('transport:'.length);
+    const transport = transports_1.labelTransportRegistry.get(name);
+    return { name, transport, format: format ?? (transport.formats.includes('zpl') ? 'zpl' : 'pdf') };
+}
+/**
+ * Issue a job: check access and confirmation, record it, then compose and
+ * deliver the codes as a sheet, a PDF, ZPL, or through a transport.
+ */
+async function issueLabels(req, auth) {
+    const loaded = await load(req.template);
+    await assertMayPrint(loaded.identity, auth);
+    if (loaded.template.sensitive && req.confirm !== true) {
+        throw new errors_1.LabelRequestError(428, 'this template prints credentials or sensitive labels; confirm to print');
+    }
+    const transport = req.output.startsWith('transport:') ? transportFor(req.output, null) : null;
+    if (!transport && !['sheet', 'pdf', 'zpl'].includes(req.output)) {
+        throw new errors_1.LabelRequestError(400, `unknown output "${req.output}"`);
+    }
+    const resolved = await (0, targets_1.resolveLabelTargets)(req.source, loaded.scheme, auth);
+    const only = req.only ? new Set(req.only) : null;
+    const targets = only ? resolved.filter((t) => only.has(loaded.identity ? t.userId : t.target)) : resolved;
+    if (targets.length === 0)
+        throw new errors_1.LabelRequestError(400, 'none of the selected labels are in the source any more');
+    const media = (0, media_2.mediaForJob)(req.layout?.media, loaded.template.media);
+    const wantsZpl = req.output === 'zpl' || transport?.format === 'zpl';
+    if (wantsZpl && media.family !== 'thermal') {
+        throw new errors_1.LabelRequestError(400, `ZPL prints on thermal media; "${media.id}" is sheet stock`);
+    }
+    const { job, replay } = await (0, jobs_1.recordLabelJob)({
+        action: 'print',
+        requested_by: auth.userId,
+        idempotency_key: req.idempotencyKey ?? null,
+        template_name: loaded.template.name,
+        template_revision: loaded.template.revision,
+        template_snapshot: loaded.template,
+        scheme_version: loaded.scheme.version,
+        scheme_kind: loaded.scheme.kind,
+        sensitive: loaded.template.sensitive,
+        source: req.source,
+        subject_user_ids: loaded.identity ? targets.map((t) => t.userId) : null,
+        targets: loaded.identity ? null : targets.map((t) => t.target),
+        label_count: targets.length * (req.layout?.copies ?? 1),
+        media,
+        output: req.output,
+    });
+    if (replay && (job.template_name !== loaded.template.name || job.output !== req.output)) {
+        throw new errors_1.LabelRequestError(409, 'this idempotency key was used for a different label request');
+    }
+    if (replay && transport && job.delivered_at)
+        return { job, replay, warnings: [], delivered: true };
+    // A replay prints the labels the first request recorded, nothing it did not.
+    const recorded = new Set((loaded.identity ? job.subject_user_ids : job.targets) ?? []);
+    const printing = replay ? targets.filter((t) => recorded.has(loaded.identity ? t.userId : t.target)) : targets;
+    const { sheet, warnings } = await compose(loaded, printing, req.layout, false);
+    const result = { job, replay, warnings };
+    try {
+        if (req.output === 'sheet')
+            result.sheet = sheet;
+        if (req.output === 'pdf')
+            result.pdf = await (0, render_pdf_1.renderSheetPdf)(sheet);
+        if (req.output === 'zpl')
+            result.zpl = (0, render_zpl_1.renderSheetZpl)(sheet);
+    }
+    catch (err) {
+        if (err instanceof render_zpl_1.ZplRenderError)
+            throw new errors_1.LabelRequestError(400, err.message);
+        throw err;
+    }
+    if (transport)
+        await deliver(job, transport, sheet, req.destination, result);
+    return result;
+}
+/**
+ * Send a recorded job through its transport under the delivery lease: the
+ * claim is one statement, so concurrent retries of one job send once, and a
+ * job whose sender crashed is sent by the first retry after the lease lapses.
+ */
+async function deliver(job, transport, sheet, destination, result) {
+    if (!(await (0, jobs_1.claimLabelDelivery)(job.id, config_1.config.LT_LABELS_DELIVERY_LEASE_SECONDS))) {
+        result.delivered = false;
+        return;
+    }
+    try {
+        const payload = transport.format === 'zpl' ? (0, render_zpl_1.renderSheetZpl)(sheet) : await (0, render_pdf_1.renderSheetPdf)(sheet);
+        result.receipt = await transport.transport.send({
+            jobId: job.id, format: transport.format, payload, labelCount: job.label_count, destination,
+        });
+    }
+    catch (err) {
+        await (0, jobs_1.releaseLabelDelivery)(job.id);
+        throw new errors_1.LabelRequestError(502, `transport "${transport.name}" failed: ${err?.message ?? 'unknown error'}`);
+    }
+    await (0, jobs_1.markLabelDelivered)(job.id);
+    result.delivered = true;
+}

package/build/services/labels/jobs.d.ts

@@ -0,0 +1,37 @@
+import type { LabelJob } from '../../types/labels';
+export interface NewLabelJob {
+    action: LabelJob['action'];
+    requested_by: string;
+    idempotency_key?: string | null;
+    template_name: string;
+    template_revision: number;
+    template_snapshot: unknown;
+    scheme_version: number;
+    scheme_kind: string;
+    sensitive: boolean;
+    source: unknown;
+    subject_user_ids: string[] | null;
+    targets: string[] | null;
+    label_count: number;
+    media: unknown;
+    output: string;
+}
+/** Record a job. With an idempotency key already used, returns that job and `replay: true`. */
+export declare function recordLabelJob(job: NewLabelJob): Promise<{
+    job: LabelJob;
+    replay: boolean;
+}>;
+/** True when this caller now holds the job's delivery lease. */
+export declare function claimLabelDelivery(id: string, leaseSeconds: number): Promise<boolean>;
+export declare function markLabelDelivered(id: string): Promise<void>;
+/** Give the lease back after a failed send, so a retry need not wait for it to lapse. */
+export declare function releaseLabelDelivery(id: string): Promise<void>;
+export declare function getLabelJob(id: string): Promise<LabelJob | null>;
+export declare function listLabelJobs(opts: {
+    readerId: string;
+    seesCredentials: boolean;
+    template?: string;
+    subjectUserId?: string;
+    limit?: number;
+    offset?: number;
+}): Promise<LabelJob[]>;

package/build/services/labels/jobs.js

@@ -0,0 +1,75 @@
+"use strict";
+// lt_label_jobs: insert-only. A print row is written before any code leaves
+// the server; a repeated idempotency key returns the first row.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.recordLabelJob = recordLabelJob;
+exports.claimLabelDelivery = claimLabelDelivery;
+exports.markLabelDelivered = markLabelDelivered;
+exports.releaseLabelDelivery = releaseLabelDelivery;
+exports.getLabelJob = getLabelJob;
+exports.listLabelJobs = listLabelJobs;
+const db_1 = require("../../lib/db");
+const INSERT_JOB = `
+  INSERT INTO lt_label_jobs (
+    action, requested_by, idempotency_key, template_name, template_revision, template_snapshot,
+    scheme_version, scheme_kind, sensitive, source, subject_user_ids, targets, label_count, media, output
+  ) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15)
+  ON CONFLICT (idempotency_key) DO NOTHING
+  RETURNING *`;
+const GET_JOB_BY_KEY = 'SELECT * FROM lt_label_jobs WHERE idempotency_key = $1';
+/** Take the delivery lease: only an undelivered job whose lease is free or lapsed. One statement, so one claimer wins. */
+const CLAIM_DELIVERY = `
+  UPDATE lt_label_jobs SET delivery_claimed_at = NOW()
+  WHERE id = $1 AND delivered_at IS NULL
+    AND (delivery_claimed_at IS NULL OR delivery_claimed_at < NOW() - make_interval(secs => $2))
+  RETURNING id`;
+const MARK_DELIVERED = 'UPDATE lt_label_jobs SET delivered_at = NOW() WHERE id = $1 AND delivered_at IS NULL';
+const RELEASE_DELIVERY = 'UPDATE lt_label_jobs SET delivery_claimed_at = NULL WHERE id = $1 AND delivered_at IS NULL';
+const GET_JOB = 'SELECT * FROM lt_label_jobs WHERE id = $1';
+/** History as a reader may see it: everything for an issuer; item jobs and their own otherwise. */
+const LIST_JOBS = `
+  SELECT * FROM lt_label_jobs
+  WHERE ($1::boolean OR NOT sensitive OR requested_by = $2::uuid)
+    AND ($3::text IS NULL OR template_name = $3)
+    AND ($4::uuid IS NULL OR $4::uuid = ANY(subject_user_ids))
+  ORDER BY created_at DESC
+  LIMIT $5 OFFSET $6`;
+function mapJob(row) {
+    return { ...row };
+}
+/** Record a job. With an idempotency key already used, returns that job and `replay: true`. */
+async function recordLabelJob(job) {
+    const { rows } = await (0, db_1.getPool)().query(INSERT_JOB, [
+        job.action, job.requested_by, job.idempotency_key ?? null, job.template_name, job.template_revision,
+        JSON.stringify(job.template_snapshot), job.scheme_version, job.scheme_kind, job.sensitive,
+        JSON.stringify(job.source), job.subject_user_ids, job.targets, job.label_count,
+        JSON.stringify(job.media), job.output,
+    ]);
+    if (rows[0])
+        return { job: mapJob(rows[0]), replay: false };
+    const existing = await (0, db_1.getPool)().query(GET_JOB_BY_KEY, [job.idempotency_key]);
+    return { job: mapJob(existing.rows[0]), replay: true };
+}
+/** True when this caller now holds the job's delivery lease. */
+async function claimLabelDelivery(id, leaseSeconds) {
+    const { rows } = await (0, db_1.getPool)().query(CLAIM_DELIVERY, [id, leaseSeconds]);
+    return rows.length > 0;
+}
+async function markLabelDelivered(id) {
+    await (0, db_1.getPool)().query(MARK_DELIVERED, [id]);
+}
+/** Give the lease back after a failed send, so a retry need not wait for it to lapse. */
+async function releaseLabelDelivery(id) {
+    await (0, db_1.getPool)().query(RELEASE_DELIVERY, [id]);
+}
+async function getLabelJob(id) {
+    const { rows } = await (0, db_1.getPool)().query(GET_JOB, [id]);
+    return rows[0] ? mapJob(rows[0]) : null;
+}
+async function listLabelJobs(opts) {
+    const { rows } = await (0, db_1.getPool)().query(LIST_JOBS, [
+        opts.seesCredentials, opts.readerId, opts.template ?? null, opts.subjectUserId ?? null,
+        Math.min(opts.limit ?? 50, 200), opts.offset ?? 0,
+    ]);
+    return rows.map(mapJob);
+}

package/build/services/labels/media.d.ts

@@ -0,0 +1,11 @@
+import type { LabelMedia } from '../../shared/labels/types';
+/** Replace the host's media presets; each must fit its page and not shadow a shipped id. */
+export declare function registerLabelMedia(media: LabelMedia[]): void;
+/** Set the deployment's default media; it must be a known preset. */
+export declare function setDefaultLabelMedia(id: string): void;
+export declare function labelMediaPresets(): LabelMedia[];
+export declare function defaultLabelMediaId(): string;
+/** The media a job prints on: the job's choice, the template's, then the deployment default. */
+export declare function mediaForJob(requested: string | LabelMedia | undefined, templateMedia: string | null): LabelMedia;
+/** Restore the shipped presets and the configured default. For tests. */
+export declare function resetLabelMedia(): void;

package/build/services/labels/media.js

@@ -0,0 +1,44 @@
+"use strict";
+// The media a deployment prints on: the shipped presets plus any the host
+// declares in start({ labels: { media } }).
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerLabelMedia = registerLabelMedia;
+exports.setDefaultLabelMedia = setDefaultLabelMedia;
+exports.labelMediaPresets = labelMediaPresets;
+exports.defaultLabelMediaId = defaultLabelMediaId;
+exports.mediaForJob = mediaForJob;
+exports.resetLabelMedia = resetLabelMedia;
+const config_1 = require("../../modules/config");
+const media_1 = require("../../shared/labels/media");
+let hostMedia = [];
+let defaultMediaId = config_1.config.LT_LABELS_DEFAULT_MEDIA;
+/** Replace the host's media presets; each must fit its page and not shadow a shipped id. */
+function registerLabelMedia(media) {
+    for (const m of media) {
+        (0, media_1.assertValidMedia)(m);
+        if (media_1.LABEL_MEDIA.some((shipped) => shipped.id === m.id)) {
+            throw new Error(`label media "${m.id}" is a shipped preset; give the host preset its own id`);
+        }
+    }
+    hostMedia = [...media];
+}
+/** Set the deployment's default media; it must be a known preset. */
+function setDefaultLabelMedia(id) {
+    (0, media_1.resolveMedia)(id, labelMediaPresets());
+    defaultMediaId = id;
+}
+function labelMediaPresets() {
+    return [...media_1.LABEL_MEDIA, ...hostMedia];
+}
+function defaultLabelMediaId() {
+    return defaultMediaId;
+}
+/** The media a job prints on: the job's choice, the template's, then the deployment default. */
+function mediaForJob(requested, templateMedia) {
+    return (0, media_1.resolveMedia)(requested ?? templateMedia ?? defaultMediaId, labelMediaPresets());
+}
+/** Restore the shipped presets and the configured default. For tests. */
+function resetLabelMedia() {
+    hostMedia = [];
+    defaultMediaId = config_1.config.LT_LABELS_DEFAULT_MEDIA;
+}

package/build/services/labels/reissue.d.ts

@@ -0,0 +1,13 @@
+import type { LTApiAuth } from '../../types/sdk';
+import type { LabelLayoutRequest } from '../../types/labels';
+import { type LabelIssueResult } from './issue';
+export interface ReissueRequest {
+    userId: string;
+    template: string;
+    layout?: LabelLayoutRequest;
+    output: 'sheet' | 'pdf' | 'zpl' | `transport:${string}`;
+    confirm?: boolean;
+}
+export declare function reissueBadge(req: ReissueRequest, auth: LTApiAuth): Promise<LabelIssueResult & {
+    reissueJobId: string;
+}>;

package/build/services/labels/reissue.js

@@ -0,0 +1,65 @@
+"use strict";
+// Reissue a badge: rotate the user's credential and print the new badge in
+// one act. The rotation and its ledger row land in one statement, so the old
+// code stops resolving the moment the new one exists.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reissueBadge = reissueBadge;
+const types_1 = require("../../types");
+const scan_code_1 = require("../scan-code");
+const user_1 = require("../user");
+const errors_1 = require("./errors");
+const issue_1 = require("./issue");
+const media_1 = require("./media");
+const templates_1 = require("./templates");
+const token_1 = require("./token");
+/** The rotation and its ledger row in one statement; a refused patch becomes a label request error. */
+async function rotate(userId, set, record) {
+    try {
+        return await (0, user_1.patchUserPropertiesRecorded)(userId, { set }, record);
+    }
+    catch (err) {
+        if (err?.status === 400 || err?.status === 409)
+            throw new errors_1.LabelRequestError(err.status, err.message);
+        throw err;
+    }
+}
+async function reissueBadge(req, auth) {
+    const template = await (0, templates_1.getLabelTemplate)(req.template);
+    if (!template)
+        throw new errors_1.LabelRequestError(404, `label template "${req.template}" does not exist`);
+    const scheme = await (0, scan_code_1.getScanScheme)(template.scheme_version);
+    if (!scheme || scheme.kind !== types_1.SCAN_SCHEME_KINDS.IDENTITY) {
+        throw new errors_1.LabelRequestError(400, 'reissue needs a template on an identity scheme');
+    }
+    await (0, issue_1.assertMayPrint)(true, auth);
+    if (req.confirm !== true)
+        throw new errors_1.LabelRequestError(428, 'reissuing a badge replaces the old one; confirm to reissue');
+    const user = await (0, user_1.getUser)(req.userId);
+    if (!user)
+        throw new errors_1.LabelRequestError(404, 'user not found');
+    const media = (0, media_1.mediaForJob)(req.layout?.media, template.media);
+    const rotated = await rotate(user.id, { [scheme.target_facet]: (0, token_1.mintIdentityToken)(scheme) }, {
+        action: 'reissue',
+        requested_by: auth.userId,
+        require_active: true,
+        source: { keys: [scheme.target_facet] },
+        label_count: 1,
+        template_name: template.name,
+        template_revision: template.revision,
+        template_snapshot: template,
+        scheme_version: scheme.version,
+        scheme_kind: scheme.kind,
+        media,
+        output: req.output,
+    });
+    if (!rotated)
+        throw new errors_1.LabelRequestError(404, 'user not found');
+    const printed = await (0, issue_1.issueLabels)({
+        template: template.name,
+        source: { kind: 'users', userIds: [user.id] },
+        layout: req.layout,
+        output: req.output,
+        confirm: true,
+    }, auth);
+    return { ...printed, reissueJobId: rotated.jobId };
+}

package/build/services/labels/render-pdf.d.ts

@@ -0,0 +1,11 @@
+import type { LabelSheet } from '../../shared/labels/types';
+export interface LabelFonts {
+    regular: Uint8Array;
+    bold?: Uint8Array;
+}
+/** Fonts for label text in PDFs (TrueType or OpenType bytes). */
+export declare function registerLabelFonts(fonts: LabelFonts | null): void;
+/** Scale an SVG path of M/h/v/z commands by (sx, sy); pdf-lib's own scale is uniform. */
+export declare function scalePath(path: string, sx: number, sy: number): string;
+/** Render a sheet as a PDF document. */
+export declare function renderSheetPdf(sheet: LabelSheet): Promise<Uint8Array>;

package/build/services/labels/render-pdf.js

@@ -0,0 +1,138 @@
+"use strict";
+// LabelSheet → PDF at exact page size. Text uses Helvetica unless the host
+// registers a font (start({ labels: { font } })) for scripts beyond Latin-1.
+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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerLabelFonts = registerLabelFonts;
+exports.scalePath = scalePath;
+exports.renderSheetPdf = renderSheetPdf;
+const pdf_lib_1 = require("pdf-lib");
+const layout_1 = require("../../shared/labels/layout");
+const PT_PER_MM = 72 / 25.4;
+const BLACK = (0, pdf_lib_1.rgb)(0, 0, 0);
+const WHITE = (0, pdf_lib_1.rgb)(1, 1, 1);
+const pt = (mm) => mm * PT_PER_MM;
+let hostFonts = null;
+/** Fonts for label text in PDFs (TrueType or OpenType bytes). */
+function registerLabelFonts(fonts) {
+    hostFonts = fonts;
+}
+/** Characters Helvetica (WinAnsi) cannot draw become "?"; a host font draws them all. */
+function drawable(text, font) {
+    try {
+        font.encodeText(text);
+        return text;
+    }
+    catch {
+        return Array.from(text, (ch) => {
+            try {
+                font.encodeText(ch);
+                return ch;
+            }
+            catch {
+                return '?';
+            }
+        }).join('');
+    }
+}
+function drawElement(page, el, ox, oy, height, fonts) {
+    const y = (mm) => height - pt(oy + mm);
+    if (el.kind === 'rect') {
+        page.drawRectangle({
+            x: pt(ox + el.x), y: y(el.y + el.h), width: pt(el.w), height: pt(el.h),
+            ...(el.fill ? { color: BLACK } : { borderColor: BLACK, borderWidth: pt(el.stroke ?? 0.3) }),
+        });
+        return;
+    }
+    if (el.kind === 'text') {
+        const font = el.weight === 'bold' ? fonts.bold : fonts.regular;
+        const text = drawable(el.text, font);
+        let size = pt(el.size);
+        const max = pt(el.w);
+        const measured = font.widthOfTextAtSize(text, size);
+        if (measured > max)
+            size *= max / measured;
+        const width = font.widthOfTextAtSize(text, size);
+        const x = el.align === 'center' ? pt(ox + el.x) + (max - width) / 2 : pt(ox + el.x);
+        page.drawText(text, { x, y: y(el.y + el.size * 0.8), size, font, color: el.inverse ? WHITE : BLACK });
+        return;
+    }
+    if (el.masked) {
+        page.drawRectangle({ x: pt(ox + el.x), y: y(el.y + el.h), width: pt(el.w), height: pt(el.h), color: (0, pdf_lib_1.rgb)(0.87, 0.87, 0.87) });
+        return;
+    }
+    const scaleY = el.symbology === 'code128' ? pt(el.h) : pt(el.moduleMm);
+    page.drawSvgPath(scalePath(el.path, pt(el.moduleMm), scaleY), { x: pt(ox + el.x), y: height - pt(oy + el.y), color: BLACK });
+}
+/** Scale an SVG path of M/h/v/z commands by (sx, sy); pdf-lib's own scale is uniform. */
+function scalePath(path, sx, sy) {
+    return path.replace(/([Mhv])(-?[\d.]+)(?: (-?[\d.]+))?/g, (_m, cmd, a, b) => {
+        if (cmd === 'M')
+            return `M${Number(a) * sx} ${Number(b) * sy}`;
+        return `${cmd}${Number(a) * (cmd === 'h' ? sx : sy)}`;
+    });
+}
+/** Render a sheet as a PDF document. */
+async function renderSheetPdf(sheet) {
+    const doc = await pdf_lib_1.PDFDocument.create();
+    let fonts;
+    if (hostFonts) {
+        const fontkit = (await Promise.resolve().then(() => __importStar(require('@pdf-lib/fontkit')))).default;
+        doc.registerFontkit(fontkit);
+        const regular = await doc.embedFont(hostFonts.regular, { subset: true });
+        fonts = { regular, bold: hostFonts.bold ? await doc.embedFont(hostFonts.bold, { subset: true }) : regular };
+    }
+    else {
+        fonts = { regular: await doc.embedFont(pdf_lib_1.StandardFonts.Helvetica), bold: await doc.embedFont(pdf_lib_1.StandardFonts.HelveticaBold) };
+    }
+    const { media } = sheet;
+    const width = pt(media.pageWidthMm);
+    const height = pt(media.pageHeightMm);
+    for (const sheetPage of sheet.pages) {
+        const page = doc.addPage([width, height]);
+        if (sheet.cutMarks) {
+            for (const [x1, y1, x2, y2] of (0, layout_1.cutMarkSegments)(media)) {
+                page.drawLine({ start: { x: pt(x1), y: height - pt(y1) }, end: { x: pt(x2), y: height - pt(y2) }, thickness: pt(0.15), color: BLACK });
+            }
+        }
+        for (const placed of sheetPage.labels) {
+            for (const el of placed.elements)
+                drawElement(page, el, placed.x, placed.y, height, fonts);
+        }
+    }
+    doc.setProducer('Long Tail label sheets');
+    doc.setCreationDate(new Date(0));
+    return doc.save();
+}

package/build/services/labels/targets.d.ts

@@ -0,0 +1,18 @@
+import { type ScanScheme } from '../../types';
+import type { LTApiAuth } from '../../types/sdk';
+import type { LabelSource, LabelTarget } from '../../types/labels';
+export declare const MAX_RANGE_PAD = 12;
+/** Targets from pasted lines or CSV. A first row naming `target` is a header; its columns become item tokens. */
+export declare function parseListSource(text: string): LabelTarget[];
+/** Targets from a numeric run: prefix + zero-padded number + suffix. */
+export declare function expandRangeSource(source: Extract<LabelSource, {
+    kind: 'range';
+}>, max: number): LabelTarget[];
+/**
+ * The targets a source names. Identity schemes read users only: a pasted or
+ * ranged credential would mint a badge for no one. Rows are read as the
+ * caller, so a job never prints what the caller cannot see.
+ */
+export declare function resolveLabelTargets(source: LabelSource, scheme: ScanScheme, auth: LTApiAuth): Promise<LabelTarget[]>;
+/** Marks which action targets name a row today, in one statement. */
+export declare function markResolvedTargets(targets: LabelTarget[], scheme: ScanScheme): Promise<void>;