@khalido/home 0.1.3 → 0.2.1

package/dist/connectors/hue/index.js

@@ -1,12 +1,14 @@
 import { asOf, realClock } from "../../clock.js";
-import { errorText } from "../../connector.js";
+import { errorText, isRejectedKey } from "../../connector.js";
 import { z } from "zod";
 import { lostDetail, relocator } from "../../discover.js";
 import { envName, filePath, deviceRecords, } from "../../home.js";
 import { bunPinnedFetch, hueClient } from "./client.js";
-import { hueEvents, isRejectedKey } from "./events.js";
+import { hueEvents } from "./events.js";
 import { groups, lights, reduce, snapshotFrom, } from "./state.js";
-export { bunPinnedFetch, HueError, hueClient, pair, } from "./client.js";
+export { HUE_BRIDGE_ROOT_CA } from "./ca.js";
+export { colorToXy, kelvinToMirek, mirekToKelvin, xyToHex, } from "./color.js";
+export { bunPinnedFetch, CONFIRM_MS, HueError, hueClient, pair, pairWhenPressed, } from "./client.js";
 export { groups, homeGroupedLightId, lights, scenes, } from "./state.js";
 /** A Hue bridge in a home config: what it takes to reach it. Its model and software come live into the snapshot. */
 export const configSchema = z.looseObject({
@@ -16,7 +18,9 @@ export const configSchema = z.looseObject({
         .string()
         .describe("the bridge id, the CN its certificate must carry: its identity"),
     key: envName.describe("env name holding the application key from `home pair`"),
-    ca: filePath.describe("Signify's root CA (PEM), relative to the config file"),
+    ca: filePath
+        .optional()
+        .describe("a root CA (PEM) to trust instead of Signify's two, which the package carries; relative to the config file"),
 });
 /**
  * Hue as a home integration: a full read on every (re)connect, then patched from the event stream; `refresh` re-reads it all.
@@ -162,8 +166,20 @@ const view = (s) => ({
         brightness,
     })),
 });
-/** "Kitchen: on · 40%", "Kitchen: off", or the name alone when the bridge hasn't said. */
-const onText = (v) => `${v.name ?? v.id}${v.on === undefined ? "" : `: ${v.on ? `on${v.brightness === undefined ? "" : ` · ${Math.round(v.brightness)}%`}` : "off"}`}`;
+/** A light, room or zone in a line: "Kitchen: on · 40%", "Desk: on · 40% · 2700 K", "Strip: on · 80% · #ff8800", "Kitchen: off", or the name alone when the bridge hasn't said. */
+export const hueText = (v) => {
+    if (v.on === undefined)
+        return v.name ?? v.id;
+    const parts = v.on
+        ? [
+            "on",
+            v.brightness === undefined ? "" : `${Math.round(v.brightness)}%`,
+            // A colour light showing a white reports both; the white is what it is showing.
+            v.kelvin !== undefined ? `${v.kelvin} K` : (v.hex ?? ""),
+        ]
+        : ["off"];
+    return `${v.name ?? v.id}: ${parts.filter(Boolean).join(" · ")}`;
+};
 /** Every light, then every room and zone. A light's `available` is its Zigbee link; a group's `members` are its lights. */
 export function hueHomeDevices(part) {
     const s = part?.state;
@@ -181,7 +197,7 @@ export function hueHomeDevices(part) {
             ...(l.reachable === undefined ? {} : { available: l.reachable }),
             ...on(l),
             asOf: s.asOf,
-            text: onText(l),
+            text: hueText(l),
             detail: l,
         })),
         ...groups(s).map((g) => ({
@@ -191,7 +207,7 @@ export function hueHomeDevices(part) {
             kind: "group",
             ...on(g),
             asOf: s.asOf,
-            text: onText(g),
+            text: hueText(g),
             members: g.lightIds,
             detail: g,
         })),
@@ -223,7 +239,8 @@ export const manifest = {
         {
             name: "HUE_CA_FILE",
             example: "/path/to/hue-root-ca.pem",
-            what: "until HUE_BRIDGE_ROOT_CA ships in src/connectors/hue/",
+            optional: true,
+            what: "a root CA to trust instead of Signify's two, which the package carries",
         },
     ],
     files: ["ca"],
@@ -232,7 +249,7 @@ export const manifest = {
         if (!state)
             return [];
         const { lightsOn } = view(state);
-        return [`${lightsOn} lights on`, ...groups(state).map(onText)];
+        return [`${lightsOn} lights on`, ...groups(state).map(hueText)];
     },
     record: ({ state }) => (state ? view(state) : {}),
 };

package/dist/connectors/hue/schemas.d.ts

@@ -19,6 +19,33 @@ export declare const Resource: z.ZodObject<{
     dimming: z.ZodOptional<z.ZodObject<{
         brightness: z.ZodNumber;
     }, z.core.$loose>>;
+    color: z.ZodCatch<z.ZodOptional<z.ZodObject<{
+        xy: z.ZodCatch<z.ZodOptional<z.ZodObject<{
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+        }, z.core.$loose>>>;
+        gamut: z.ZodCatch<z.ZodOptional<z.ZodObject<{
+            red: z.ZodObject<{
+                x: z.ZodNumber;
+                y: z.ZodNumber;
+            }, z.core.$loose>;
+            green: z.ZodObject<{
+                x: z.ZodNumber;
+                y: z.ZodNumber;
+            }, z.core.$loose>;
+            blue: z.ZodObject<{
+                x: z.ZodNumber;
+                y: z.ZodNumber;
+            }, z.core.$loose>;
+        }, z.core.$loose>>>;
+    }, z.core.$loose>>>;
+    color_temperature: z.ZodCatch<z.ZodOptional<z.ZodObject<{
+        mirek: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        mirek_schema: z.ZodOptional<z.ZodObject<{
+            mirek_minimum: z.ZodOptional<z.ZodNumber>;
+            mirek_maximum: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$loose>>;
+    }, z.core.$loose>>>;
     children: z.ZodOptional<z.ZodArray<z.ZodObject<{
         rid: z.ZodString;
         rtype: z.ZodString;

package/dist/connectors/hue/schemas.js

@@ -4,6 +4,7 @@ import { z } from "zod";
 // field is unconfirmed from the primary source. Only the fields the snapshot reads are parsed;
 // all are optional and unknown fields pass through, so a schema change degrades, never throws.
 const ref = z.object({ rid: z.string(), rtype: z.string() });
+const xy = z.looseObject({ x: z.number(), y: z.number() });
 /** The resource kinds this library reads. */
 export const KINDS = [
     "light",
@@ -22,6 +23,31 @@ export const Resource = z.looseObject({
     metadata: z.looseObject({ name: z.string().optional() }).optional(),
     on: z.looseObject({ on: z.boolean() }).optional(),
     dimming: z.looseObject({ brightness: z.number() }).optional(),
+    // A light's colour and the triangle of colours it can show; absent on a white light. A shape this doesn't expect
+    // reads as absent, so one odd light never fails the whole read.
+    color: z
+        .looseObject({
+        xy: xy.optional().catch(undefined),
+        gamut: z
+            .looseObject({ red: xy, green: xy, blue: xy })
+            .optional()
+            .catch(undefined),
+    })
+        .optional()
+        .catch(undefined),
+    // mirek is null while the light shows a colour; the schema is this light's own range.
+    color_temperature: z
+        .looseObject({
+        mirek: z.number().nullable().optional(),
+        mirek_schema: z
+            .looseObject({
+            mirek_minimum: z.number().optional(),
+            mirek_maximum: z.number().optional(),
+        })
+            .optional(),
+    })
+        .optional()
+        .catch(undefined),
     children: z.array(ref).optional(),
     services: z.array(ref).optional(),
     group: ref.optional(), // scene: the room or zone it belongs to

package/dist/connectors/hue/state.d.ts

@@ -1,3 +1,4 @@
+import { type Gamut, type XY } from "./color.ts";
 import type { HueEvent, Resource } from "./schemas.ts";
 /** Every resource on the bridge by id, from the last full read plus every event since. `asOf` is local time it was last known fresh. */
 export type HueSnapshot = {
@@ -17,8 +18,16 @@ export type LightView = {
     on?: boolean;
     brightness?: number;
     reachable?: boolean;
+    /** White temperature in kelvin, while the light shows a white; its range is `kelvinRange` (warmest, coolest). */
+    kelvin?: number;
+    kelvinRange?: [number, number];
+    /** The colour it shows: the bridge's `xy`, and `hex` for a screen (the hue at full brightness). Colour lights only. */
+    xy?: XY;
+    hex?: string;
+    /** The colours it can show. Present on a colour light, so its presence says "takes a colour". */
+    gamut?: Gamut;
 };
-/** Every light, with on, brightness and reachability. */
+/** Every light, with on, brightness, reachability, and its white temperature and colour where it has them. */
 export declare function lights(s: HueSnapshot): LightView[];
 /** A room or zone as a row shows it, with its grouped light's state. */
 export type GroupView = {

package/dist/connectors/hue/state.js

@@ -1,3 +1,4 @@
+import { mirekToKelvin, xyToHex } from "./color.js";
 /** A snapshot from one full `get()`. */
 export function snapshotFrom(resources, asOf) {
     return {
@@ -32,7 +33,7 @@ const ofType = (s, type) => Object.values(s.resources).filter((r) => r.type ===
 const groupedLightOf = (s, r) => r.services
     ?.map((x) => s.resources[x.rid])
     .find((x) => x?.type === "grouped_light");
-/** Every light, with on, brightness and reachability. */
+/** Every light, with on, brightness, reachability, and its white temperature and colour where it has them. */
 export function lights(s) {
     const zigbee = ofType(s, "zigbee_connectivity");
     return ofType(s, "light").map((l) => {
@@ -43,9 +44,27 @@ export function lights(s) {
             on: l.on?.on,
             brightness: l.dimming?.brightness,
             reachable: link ? link.status === "connected" : undefined,
+            ...colorOf(l),
         };
     });
 }
+/** A light's temperature and colour fields, only those the bridge reported. */
+function colorOf(l) {
+    const out = {};
+    const ct = l.color_temperature;
+    if (typeof ct?.mirek === "number")
+        out.kelvin = mirekToKelvin(ct.mirek);
+    const { mirek_minimum: min, mirek_maximum: max } = ct?.mirek_schema ?? {};
+    if (min !== undefined && max !== undefined)
+        out.kelvinRange = [mirekToKelvin(max), mirekToKelvin(min)];
+    if (l.color?.xy) {
+        out.xy = l.color.xy;
+        out.hex = xyToHex(l.color.xy);
+    }
+    if (l.color?.gamut)
+        out.gamut = l.color.gamut;
+    return out;
+}
 /** Rooms and zones. A room's children are devices; a zone's are lights. */
 export function groups(s) {
     const all = ofType(s, "light");

package/dist/connectors/printers/client.d.ts

@@ -17,12 +17,47 @@ export declare function printerUrl(a: PrinterAddress): {
     secure: boolean;
     path: string;
 };
-/**
- * Get-Printer-Attributes over HTTP, through `fetchTimeout`. A non-ok HTTP status or an IPP status of 0x0100 and up throws a
- * ConnectorError saying which. Returns the whole response; `attributesOf` gives the printer's attributes.
- */
-export declare function getPrinterAttributes(fetcher: typeof fetch, address: PrinterAddress, options?: {
+type CallOptions = {
     requestId?: number;
     signal?: AbortSignal;
     timeoutMs?: number;
-}): Promise<IppMessage>;
+};
+/** Get-Printer-Attributes: the whole response; `attributesOf` gives the printer's attributes. `requested` replaces the poll's list. */
+export declare const getPrinterAttributes: (fetcher: typeof fetch, address: PrinterAddress, options?: CallOptions & {
+    requested?: string[];
+}) => Promise<IppMessage>;
+/** Identify-Printer: the printer shows or sounds that it is the one (PWG 5100.13). No paper. */
+export declare const identifyPrinter: (fetcher: typeof fetch, address: PrinterAddress, options?: CallOptions) => Promise<unknown>;
+/**
+ * What a job says about itself. `format` is the document's MIME type and must be one the printer lists; `media` a PWG
+ * media name (`iso_a4_210x297mm`). `sides` defaults to `one-sided`, sent explicitly so a printer's duplex default
+ * never applies to a document made for one side.
+ */
+export type PrintJob = {
+    format: string;
+    name?: string;
+    user?: string;
+    media?: string;
+    sides?: "one-sided" | "two-sided-long-edge" | "two-sided-short-edge";
+    copies?: number;
+};
+/** A job the printer took: its id, and its state when it answered (RFC 8011: 3 pending, 5 processing, 9 completed). */
+export type PrintedJob = {
+    jobId?: number;
+    state?: number;
+    reasons?: string[];
+};
+/** Validate-Job: the printer checks the job's attributes as Print-Job would, and prints nothing. */
+export declare const validateJob: (fetcher: typeof fetch, address: PrinterAddress, job: PrintJob, options?: CallOptions) => Promise<unknown>;
+/** No upload waits longer than this: a page of raster is a few hundred kB, and a printer can be slow to take it. */
+export declare const PRINT_TIMEOUT_MS = 60000;
+/**
+ * Print-Job: the job's attributes and the document in one request. A timeout leaves it unknown whether the printer took
+ * the job, so the error says not to send it again blindly.
+ */
+export declare function printJob(fetcher: typeof fetch, address: PrinterAddress, job: PrintJob, document: Uint8Array, options?: CallOptions): Promise<PrintedJob>;
+/** Cancel-Job: stop a job by its id, from Print-Job's answer. */
+export declare const cancelJob: (fetcher: typeof fetch, address: PrinterAddress, jobId: number, options?: CallOptions & {
+    user?: string;
+}) => Promise<unknown>;
+export {};

package/dist/connectors/printers/client.js

@@ -1,8 +1,8 @@
 import { ConnectorError, fetchTimeout } from "../../connector.js";
-import { attributesOf, decodeMessage, getPrinterAttributesRequest, } from "./codec.js";
-// Pure reads: a `fetch`, an address and a path come in, the printer's attributes go out. No writes here yet.
-// TODO(writes, behind KO's hand): Identify-Printer (0x003C, a beep) first, then Print-Job (0x0002) with application/pdf
-// where `document-format-supported` lists it. Each is one more request builder in codec.ts and one function here.
+import { attributesOf, decodeMessage, getPrinterAttributesRequest, OPERATION, operationRequest, TAG, } from "./codec.js";
+// Pure calls: a `fetch`, an address and the bytes to send come in, the printer's answer goes out. The reads are
+// Get-Printer-Attributes; the writes Identify-Printer, Validate-Job, Print-Job and Cancel-Job. The document is the caller's,
+// already in a format the printer lists (`document-format-supported`): this package makes no PDF into raster.
 /** Everything the integration reads from one printer. */
 export const REQUESTED = [
     "printer-state",
@@ -51,15 +51,15 @@ const STATUS = {
     0x0507: "server-error-busy",
 };
 /**
- * Get-Printer-Attributes over HTTP, through `fetchTimeout`. A non-ok HTTP status or an IPP status of 0x0100 and up throws a
- * ConnectorError saying which. Returns the whole response; `attributesOf` gives the printer's attributes.
+ * One IPP request over HTTP, through `fetchTimeout`. A non-ok HTTP status or an IPP status of 0x0100 and up throws a
+ * ConnectorError saying which (`code: "ipp"`, the IPP status in `status`).
  */
-export async function getPrinterAttributes(fetcher, address, options = {}) {
+async function call(fetcher, address, body, options = {}) {
     const url = printerUrl(address);
     const res = await fetchTimeout(fetcher, url.http, {
         method: "POST",
         headers: { "content-type": "application/ipp", accept: "application/ipp" },
-        body: getPrinterAttributesRequest(url.ipp, REQUESTED, options.requestId),
+        body: body(url.ipp),
     }, options);
     if (!res.ok)
         throw new ConnectorError(`HTTP ${res.status} on POST /${url.path}`, {
@@ -72,3 +72,76 @@ export async function getPrinterAttributes(fetcher, address, options = {}) {
     }
     return message;
 }
+/** Get-Printer-Attributes: the whole response; `attributesOf` gives the printer's attributes. `requested` replaces the poll's list. */
+export const getPrinterAttributes = (fetcher, address, options = {}) => call(fetcher, address, (uri) => getPrinterAttributesRequest(uri, options.requested ?? REQUESTED, options.requestId), options);
+/** Identify-Printer: the printer shows or sounds that it is the one (PWG 5100.13). No paper. */
+export const identifyPrinter = (fetcher, address, options = {}) => call(fetcher, address, (uri) => operationRequest(OPERATION.identifyPrinter, uri, {
+    requestId: options.requestId,
+}), options);
+/** Who asks: RFC 8011 has a client send it on every operation. `home` unless the caller names someone. */
+const userAttribute = (user = "home") => ({
+    name: "requesting-user-name",
+    tag: TAG.nameWithoutLanguage,
+    values: [user],
+});
+function jobAttributes(job) {
+    const attributes = [
+        userAttribute(job.user),
+        {
+            name: "job-name",
+            tag: TAG.nameWithoutLanguage,
+            values: [job.name ?? "home"],
+        },
+        { name: "document-format", tag: TAG.mimeMediaType, values: [job.format] },
+    ];
+    const attrs = [
+        { name: "sides", tag: TAG.keyword, values: [job.sides ?? "one-sided"] },
+    ];
+    if (job.media)
+        attrs.push({ name: "media", tag: TAG.keyword, values: [job.media] });
+    if (job.copies !== undefined)
+        attrs.push({ name: "copies", tag: TAG.integer, values: [job.copies] });
+    return { attributes, job: attrs };
+}
+/** Validate-Job: the printer checks the job's attributes as Print-Job would, and prints nothing. */
+export const validateJob = (fetcher, address, job, options = {}) => call(fetcher, address, (uri) => operationRequest(OPERATION.validateJob, uri, {
+    ...jobAttributes(job),
+    requestId: options.requestId,
+}), options);
+/** No upload waits longer than this: a page of raster is a few hundred kB, and a printer can be slow to take it. */
+export const PRINT_TIMEOUT_MS = 60_000;
+/**
+ * Print-Job: the job's attributes and the document in one request. A timeout leaves it unknown whether the printer took
+ * the job, so the error says not to send it again blindly.
+ */
+export async function printJob(fetcher, address, job, document, options = {}) {
+    let answer;
+    try {
+        answer = await call(fetcher, address, (uri) => operationRequest(OPERATION.printJob, uri, {
+            ...jobAttributes(job),
+            data: document,
+            requestId: options.requestId,
+        }), { timeoutMs: PRINT_TIMEOUT_MS, ...options });
+    }
+    catch (error) {
+        if (error instanceof Error && error.name === "TimeoutError")
+            throw new ConnectorError("the printer did not answer the print job in time; it may still print, so check the printer before sending it again", { code: "timeout", cause: error });
+        throw error;
+    }
+    const a = attributesOf(answer, TAG.job);
+    const n = (v) => (typeof v === "number" ? v : undefined);
+    const reasons = a["job-state-reasons"]?.filter((r) => typeof r === "string");
+    return {
+        jobId: n(a["job-id"]?.[0]),
+        state: n(a["job-state"]?.[0]),
+        reasons: reasons?.length ? reasons : undefined,
+    };
+}
+/** Cancel-Job: stop a job by its id, from Print-Job's answer. */
+export const cancelJob = (fetcher, address, jobId, options = {}) => call(fetcher, address, (uri) => operationRequest(OPERATION.cancelJob, uri, {
+    requestId: options.requestId,
+    attributes: [
+        { name: "job-id", tag: TAG.integer, values: [jobId] },
+        userAttribute(options.user), // printers often let only the job's owner cancel it
+    ],
+}), options);

package/dist/connectors/printers/codec.d.ts

@@ -23,9 +23,13 @@ export declare const TAG: {
     readonly naturalLanguage: 72;
     readonly mimeMediaType: 73;
 };
-/** The operation ids this package sends. Identify-Printer (0x003C) and Print-Job (0x0002) are the writes that come later. */
+/** The operation ids this package sends (RFC 8011; Identify-Printer from PWG 5100.13). */
 export declare const OPERATION: {
+    readonly printJob: 2;
+    readonly validateJob: 4;
+    readonly cancelJob: 8;
     readonly getPrinterAttributes: 11;
+    readonly identifyPrinter: 60;
 };
 export type IppRange = {
     lower: number;
@@ -65,8 +69,18 @@ export type IppMessage = {
 };
 /** A message as bytes. Collections are not encoded (a Get-Printer-Attributes request has none). */
 export declare function encodeMessage(m: IppMessage): Uint8Array<ArrayBuffer>;
-/** The Get-Printer-Attributes request: IPP 2.0, utf-8, English, the printer's `ipp://` URI, and the attributes wanted. */
-export declare function getPrinterAttributesRequest(printerUri: string, requested: string[], requestId?: number): Uint8Array<ArrayBuffer>;
+/**
+ * A request to one printer: IPP 2.0, utf-8, English, the printer's `ipp://` URI, then `attributes` in the operation
+ * group, `job` (when given) in a job group, and `data` (a document) after the end tag.
+ */
+export declare function operationRequest(code: number, printerUri: string, options?: {
+    attributes?: IppAttribute[];
+    job?: IppAttribute[];
+    data?: Uint8Array;
+    requestId?: number;
+}): Uint8Array<ArrayBuffer>;
+/** The Get-Printer-Attributes request: the attributes wanted. */
+export declare const getPrinterAttributesRequest: (printerUri: string, requested: string[], requestId?: number) => Uint8Array<ArrayBuffer>;
 /**
  * A message's bytes as groups of attributes. An unknown or malformed value is kept as `IppUnknown`, never thrown; only a
  * message that cannot be walked (cut short, a value before any attribute) throws. A collection and its members are skipped.

package/dist/connectors/printers/codec.js

@@ -27,8 +27,14 @@ export const TAG = {
     naturalLanguage: 0x48,
     mimeMediaType: 0x49,
 };
-/** The operation ids this package sends. Identify-Printer (0x003C) and Print-Job (0x0002) are the writes that come later. */
-export const OPERATION = { getPrinterAttributes: 0x000b };
+/** The operation ids this package sends (RFC 8011; Identify-Printer from PWG 5100.13). */
+export const OPERATION = {
+    printJob: 0x0002,
+    validateJob: 0x0004,
+    cancelJob: 0x0008,
+    getPrinterAttributes: 0x000b,
+    identifyPrinter: 0x003c,
+};
 const STRING_TAGS = new Set([
     TAG.textWithoutLanguage,
     TAG.nameWithoutLanguage,
@@ -94,14 +100,21 @@ export function encodeMessage(m) {
             });
     }
     out.push(TAG.end);
-    return Uint8Array.from([...out, ...(m.data ?? [])]);
+    const bytes = new Uint8Array(out.length + (m.data?.length ?? 0));
+    bytes.set(out);
+    if (m.data)
+        bytes.set(m.data, out.length);
+    return bytes;
 }
-/** The Get-Printer-Attributes request: IPP 2.0, utf-8, English, the printer's `ipp://` URI, and the attributes wanted. */
-export function getPrinterAttributesRequest(printerUri, requested, requestId = 1) {
+/**
+ * A request to one printer: IPP 2.0, utf-8, English, the printer's `ipp://` URI, then `attributes` in the operation
+ * group, `job` (when given) in a job group, and `data` (a document) after the end tag.
+ */
+export function operationRequest(code, printerUri, options = {}) {
     return encodeMessage({
         version: [2, 0],
-        code: OPERATION.getPrinterAttributes,
-        requestId,
+        code,
+        requestId: options.requestId ?? 1,
         groups: [
             {
                 tag: TAG.operation,
@@ -113,12 +126,23 @@ export function getPrinterAttributesRequest(printerUri, requested, requestId = 1
                         values: ["en"],
                     },
                     { name: "printer-uri", tag: TAG.uri, values: [printerUri] },
-                    { name: "requested-attributes", tag: TAG.keyword, values: requested },
+                    ...(options.attributes ?? []),
                 ],
             },
+            ...(options.job?.length
+                ? [{ tag: TAG.job, attributes: options.job }]
+                : []),
         ],
+        data: options.data,
     });
 }
+/** The Get-Printer-Attributes request: the attributes wanted. */
+export const getPrinterAttributesRequest = (printerUri, requested, requestId = 1) => operationRequest(OPERATION.getPrinterAttributes, printerUri, {
+    requestId,
+    attributes: [
+        { name: "requested-attributes", tag: TAG.keyword, values: requested },
+    ],
+});
 const fail = (why) => {
     throw new Error(`ipp: ${why}`);
 };

package/dist/connectors/printers/index.d.ts

@@ -5,6 +5,8 @@ import { type DeviceRecord, type Integration, type Part } from "../../home.ts";
 import type { Manifest } from "../../manifest.ts";
 import { type Printer, type PrinterStatus, type PrintersState } from "./state.ts";
 export { type Marker, type Printer, type PrintersState, type PrinterStatus, printerText, } from "./state.ts";
+export { cancelJob, identifyPrinter, type PrintedJob, type PrinterAddress, type PrintJob, printJob, validateJob, } from "./client.ts";
+export { type GreyPage, mediaPixels, pwgRaster, type RasterMedia, } from "./raster.ts";
 /** One printer in a home config. Everything the printer reports about itself (model, markers, state) comes live; `host` and `port` are only where it last answered. */
 export declare const configSchema: z.ZodObject<{
     connector: z.ZodLiteral<"printers">;

package/dist/connectors/printers/index.js

@@ -8,6 +8,8 @@ import { getPrinterAttributes, printerUrl } from "./client.js";
 import { attributesOf } from "./codec.js";
 import { printerKey, printerText, toState, } from "./state.js";
 export { printerText, } from "./state.js";
+export { cancelJob, identifyPrinter, printJob, validateJob, } from "./client.js";
+export { mediaPixels, pwgRaster, } from "./raster.js";
 /** One printer in a home config. Everything the printer reports about itself (model, markers, state) comes live; `host` and `port` are only where it last answered. */
 export const configSchema = z.looseObject({
     connector: z.literal("printers"),
@@ -92,6 +94,8 @@ export function printers(config = {}) {
             name: t.name,
             model: good.model ?? t.foundModel,
             host: t.host,
+            port: t.port,
+            rp: t.rp,
             room: t.room,
             ...(offline ? { state: "offline" } : {}),
             ipps: t.ipps,

package/dist/connectors/printers/raster.d.ts

@@ -0,0 +1,30 @@
+/** One page: `pixels` is `width × height` bytes, row by row from the top, 0 black to 255 white. */
+export type GreyPage = {
+    width: number;
+    height: number;
+    pixels: Uint8Array;
+};
+/** What every page is printed as: the printer's resolution and the PWG media name and size it lists. */
+export type RasterMedia = {
+    /** PWG self-describing name, as the printer lists it in `media-supported`: `iso_a4_210x297mm`. */
+    name: string;
+    /** dots per inch, one of the printer's `pwg-raster-document-resolution-supported`. */
+    dpi: number;
+};
+/** The pixels a page of this media is at its resolution, rounded down as macOS's filters do: A4 at 600 dpi is 4960 × 7015. */
+export declare function mediaPixels(media: RasterMedia): {
+    width: number;
+    height: number;
+};
+/**
+ * Pages as one PWG Raster document, `image/pwg-raster`. Every page must be `width × height` bytes. Pages may come one at
+ * a time (a generator), so only the packed document and the current page are held; then `total` is the page count.
+ */
+export declare function pwgRaster(pages: Iterable<GreyPage>, media: RasterMedia, total?: number): Uint8Array<ArrayBuffer>;
+/** A PWG Raster document back as pages and their headers' key fields; for tests and for checking a file before it prints. */
+export declare function readPwgRaster(file: Uint8Array): (GreyPage & {
+    dpi: number;
+    pageSizeName: string;
+    colorSpace: number;
+    bitsPerPixel: number;
+})[];