@ikalogic/at1000 0.6.0 → 0.7.0

package/build/relays.cjs

@@ -1,2 +1,2 @@
-Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require("./rolldown-runtime-CMqjfN_6.cjs");let t=require("valibot");t=e.t(t,1);const n=t.picklist([`open`,`closed`]),r=t.array(n),i=t.object({state:n}),a=t.picklist([`open`,`close`]);t.object({action:a});var o=class{fetch;constructor(e){this.fetch=e}reset(){return this.fetch(`/relays/reset`,{method:`POST`,parseResponse:()=>{}})}relay(e){return new s(this.fetch,e)}read(){return this.fetch(`/relays`,{schema:r})}open(){return this.fetch(`/relays`,{method:`POST`,body:{action:`open`},schema:r})}close(){return this.fetch(`/relays`,{method:`POST`,body:{action:`close`},schema:r})}},s=class{fetch;id;constructor(e,t){this.fetch=e,this.id=t}async read(){return(await this.fetch(`/relays/${this.id}`,{schema:i})).state}async is_open(){return await this.read()===`open`}async is_closed(){return await this.read()===`closed`}async open(){return(await this.fetch(`/relays/${this.id}`,{method:`POST`,body:{action:`open`},schema:i})).state}async close(){return(await this.fetch(`/relays/${this.id}`,{method:`POST`,body:{action:`close`},schema:i})).state}};exports.Relay=s,exports.RelaysApi=o,exports.relayState=i,exports.states=r;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require("./rolldown-runtime-BocRIvOZ.cjs");let t=require("valibot");t=e.t(t,1);const n=t.picklist([`open`,`closed`]),r=t.array(n),i=t.object({state:n}),a=t.picklist([`open`,`close`]);t.object({action:a});var o=class{fetch;constructor(e){this.fetch=e}reset(){return this.fetch(`/relays/reset`,{method:`POST`,parseResponse:()=>{}})}relay(e){return new s(this.fetch,e)}read(){return this.fetch(`/relays`,{schema:r})}open(){return this.fetch(`/relays`,{method:`POST`,body:{action:`open`},schema:r})}close(){return this.fetch(`/relays`,{method:`POST`,body:{action:`close`},schema:r})}},s=class{fetch;id;constructor(e,t){this.fetch=e,this.id=t}async read(){return(await this.fetch(`/relays/${this.id}`,{schema:i})).state}async is_open(){return await this.read()===`open`}async is_closed(){return await this.read()===`closed`}async open(){return(await this.fetch(`/relays/${this.id}`,{method:`POST`,body:{action:`open`},schema:i})).state}async close(){return(await this.fetch(`/relays/${this.id}`,{method:`POST`,body:{action:`close`},schema:i})).state}};exports.Relay=s,exports.RelaysApi=o,exports.relayState=i,exports.states=r;
 //# sourceMappingURL=relays.cjs.map

package/build/{rolldown-runtime-CMqjfN_6.cjs → rolldown-runtime-BocRIvOZ.cjs}

@@ -1 +1 @@
-var e=Object.create,t=Object.defineProperty,n=Object.getOwnPropertyDescriptor,r=Object.getOwnPropertyNames,i=Object.getPrototypeOf,a=Object.prototype.hasOwnProperty,o=(e,i,o,s)=>{if(i&&typeof i==`object`||typeof i==`function`)for(var c=r(i),l=0,u=c.length,d;l<u;l++)d=c[l],!a.call(e,d)&&d!==o&&t(e,d,{get:(e=>i[e]).bind(null,d),enumerable:!(s=n(i,d))||s.enumerable});return e},s=(n,r,a)=>(a=n==null?{}:e(i(n)),o(r||!n||!n.__esModule?t(a,`default`,{value:n,enumerable:!0}):a,n));Object.defineProperty(exports,"t",{enumerable:!0,get:function(){return s}});
+var e=Object.create,t=Object.defineProperty,n=Object.getOwnPropertyDescriptor,r=Object.getOwnPropertyNames,i=Object.getPrototypeOf,a=Object.prototype.hasOwnProperty,o=(e,i,o,s)=>{if(i&&typeof i==`object`||typeof i==`function`)for(var c=r(i),l=0,u=c.length,d;l<u;l++)d=c[l],!a.call(e,d)&&d!==o&&t(e,d,{get:(e=>i[e]).bind(null,d),enumerable:!(s=n(i,d))||s.enumerable});return e},s=(n,r,s)=>(s=n==null?{}:e(i(n)),o(r||!n||!n.__esModule||!a.call(n,`default`)?t(s,`default`,{value:n,enumerable:!0}):s,n));Object.defineProperty(exports,"t",{enumerable:!0,get:function(){return s}});

package/build/session-qWW9mqWH.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"session-qWW9mqWH.d.cts","names":[],"sources":["../src/api/session.ts"],"mappings":";;;cAKa,cAAY,EAAA;;;;;;;KAOb,eAAe,EAAE,mBAAmB;;KAGpC;EAAoB;EAA4B;EAAgB;;;;;;;;;;;;;;iBAgBtD,aACpB,iBACA,MAAM,kBACL;;cAmBU;mBACkB;EAAA,YAAA,OAAO;;;;;EAMpC,SAAS,QAAQ"}
+{"version":3,"file":"session-qWW9mqWH.d.cts","names":[],"sources":["../src/api/session.ts"],"mappings":";;;cAKa,cAAY,EAAA;;;;;;;KAOb,eAAe,EAAE,mBAAmB;;KAGpC;EAAoB;EAA4B;EAAgB;;;;;;;;;;;;;;iBAgBtD,aACpB,iBACA,MAAM,kBACL;;cAmBU;mBACkB;EAA7B,YAA6B,OAAO;;;;;EAMpC,SAAS,QAAQ"}

package/build/session-qWW9mqWH.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"session-qWW9mqWH.d.mts","names":[],"sources":["../src/api/session.ts"],"mappings":";;;cAKa,cAAY,EAAA;;;;;;;KAOb,eAAe,EAAE,mBAAmB;;KAGpC;EAAoB;EAA4B;EAAgB;;;;;;;;;;;;;;iBAgBtD,aACpB,iBACA,MAAM,kBACL;;cAmBU;mBACkB;EAAA,YAAA,OAAO;;;;;EAMpC,SAAS,QAAQ"}
+{"version":3,"file":"session-qWW9mqWH.d.mts","names":[],"sources":["../src/api/session.ts"],"mappings":";;;cAKa,cAAY,EAAA;;;;;;;KAOb,eAAe,EAAE,mBAAmB;;KAGpC;EAAoB;EAA4B;EAAgB;;;;;;;;;;;;;;iBAgBtD,aACpB,iBACA,MAAM,kBACL;;cAmBU;mBACkB;EAA7B,YAA6B,OAAO;;;;;EAMpC,SAAS,QAAQ"}

package/build/session.cjs

@@ -1 +1 @@
-Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require("./at1000-D9r6GCs0.cjs");exports.SessionApi=e.a,exports.open_session=e.o,exports.sessionState=e.s;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require("./at1000-DjoKZEha.cjs");exports.SessionApi=e.a,exports.open_session=e.o,exports.sessionState=e.s;

package/build/session.mjs

@@ -1 +1 @@
-import{a as e,o as t,s as n}from"./at1000-BGZGhgco.mjs";export{e as SessionApi,t as open_session,n as sessionState};
+import{a as e,o as t,s as n}from"./at1000-Bav5xUM1.mjs";export{e as SessionApi,t as open_session,n as sessionState};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ikalogic/at1000",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "description": "Ikalogic AT1000 API",
   "type": "module",
   "main": "./build/node.cjs",
@@ -119,38 +119,28 @@
   "scripts": {
     "build": "bun --bun tsdown && bun --bun publint",
     "check": "bun --bun tsc --noEmit && bun --bun oxlint --type-aware --deny-warnings",
+    "check:sequence-types": "bun --bun tsc --noEmit -p tsconfig.sequence-tests.json",
     "dev": "bun --bun tsdown --watch",
     "release": "bun publish",
-    "test": "bun test --coverage",
-    "docs": "bun typedoc-pkg -o build/docs"
+    "test": "bun test --coverage"
   },
   "dependencies": {
     "dns-packet": "^5.6.1",
-    "ip-address": "^10.2.0",
-    "up-fetch": "^2.6.0",
-    "valibot": "^1.4.1"
+    "ip-address": "^10.7.0",
+    "up-fetch": "^2.6.1",
+    "valibot": "^1.5.0"
   },
   "devDependencies": {
-    "@arethetypeswrong/core": "^0.18.3",
+    "@arethetypeswrong/core": "^0.18.5",
     "@ikalogic/at1000-relay-board": "0.0.1",
     "@ikalogic/bk2831e": "0.0.1",
     "@ikalogic/hm310p": "0.0.1",
     "@ikalogic/transport": "0.1.0",
-    "@types/bun": "^1.3.14",
+    "@types/bun": "^1.4.2",
     "@types/dns-packet": "^5.6.5",
-    "@types/node": "^25.9.2",
-    "@typhonjs-typedoc/typedoc-pkg": "^0.4.2",
-    "publint": "^0.3.21",
-    "tsdown": "^0.22.12",
-    "typedoc": "^0.28.19",
-    "typescript": "^6.0.3"
-  },
-  "typedocOptions": {
-    "out": "build/docs",
-    "entryPoints": [
-      "./src/browser.ts",
-      "./src/node.ts",
-      "./src/api/*"
-    ]
+    "@types/node": "^25.9.5",
+    "publint": "^0.3.24",
+    "tsdown": "^0.23.0",
+    "typescript": "^7.0.2"
   }
 }

package/build/at1000-D9r6GCs0.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"at1000-D9r6GCs0.cjs","names":["v","v","canConfig","rs232Config","rs485Config","spiConfig","i2cConfig","uartConfig","canFrame","digitalState","analogState","analogInputConfiguration","analogOutputConfiguration","digitalInputConfiguration","digitalOutputConfiguration","openDrainConfiguration","syncState","text","color","progress","playbackConfiguration","internalKnobEvent","calibrationData","calibrationState","projectEvent","updateStatus","dutState","usbState","relayState","states","format_host_for_url","format_host_for_url","ComApi","HmiApi","GpioApi","ManagementApi","PowerApi","RelaysApi"],"sources":["../src/api/session.ts","../src/api/events.ts","../src/at1000.ts"],"sourcesContent":["import type { UpFetch } from 'up-fetch';\nimport * as v from 'valibot';\n\nimport { parseApiError } from '../at1000';\n\nexport const sessionState = v.object({\n  active: v.boolean(),\n  kind: v.optional(v.picklist(['remote', 'project'])),\n  label: v.optional(v.string()),\n  project: v.optional(v.string()),\n  since: v.optional(v.number()),\n});\nexport type SessionState = v.InferOutput<typeof sessionState>;\n\n/** Body for `POST /v0/session/open`. */\nexport type SessionOpenBody = { kind: 'remote' | 'project'; label?: string; project?: string };\n\nconst openResponse = v.object({ token: v.string() });\n\n/**\n * Opens an exclusive session on the device (last-open-wins). Returns the minted\n * session token, or `undefined` when the server predates the session model.\n *\n * Deliberately uses a direct `fetch` (not the shared up-fetch client) so the\n * response status is inspectable before any structured-error handler throws:\n * pre-session servers answer the unmatched route with 404/405, which we degrade\n * to `undefined` rather than surface as a failure. A 30 s timeout (not the SDK\n * default 1 s) covers a remote-kind open synchronously stopping any running\n * project container; the host is already known-alive from the preceding info\n * probe, so the long timeout never hangs on dead hosts.\n */\nexport async function open_session(\n  baseUrl: string,\n  body: SessionOpenBody,\n): Promise<string | undefined> {\n  const response = await fetch(`${baseUrl}/session/open`, {\n    method: 'POST',\n    body: JSON.stringify(body),\n    headers: { 'content-type': 'application/json' },\n    signal: AbortSignal.timeout(30_000),\n  });\n\n  if (response.status === 404 || response.status === 405) {\n    return undefined; // legacy server without the session model\n  }\n  if (!response.ok) {\n    await parseApiError(response, 'POST');\n  }\n\n  return v.parse(openResponse, await response.json()).token;\n}\n\n/** @hideconstructor */\nexport class SessionApi {\n  constructor(private readonly fetch: UpFetch) {}\n\n  /**\n   * Reads the current device session state.\n   * @returns The active holder (kind/label/project/since) or `{ active: false }`.\n   */\n  state(): Promise<SessionState> {\n    return this.fetch('/session/state', { schema: sessionState });\n  }\n}\n","import * as v from 'valibot';\n\nimport { format_host_for_url } from '../host';\nimport {\n  canConfig,\n  canFrame,\n  i2cConfig,\n  rs232Config,\n  rs485Config,\n  spiConfig,\n  uartConfig,\n} from './com';\nimport {\n  analogInputConfiguration,\n  analogOutputConfiguration,\n  analogState,\n  digitalInputConfiguration,\n  digitalOutputConfiguration,\n  digitalState,\n  openDrainConfiguration,\n  syncState,\n} from './gpio';\nimport { color, internalKnobEvent, playbackConfiguration, progress, text } from './hmi';\nimport { calibrationData, calibrationState, projectEvent, updateStatus } from './management';\nimport { dutState, usbState } from './power';\nimport { relayState, states } from './relays';\nimport { sessionState } from './session';\n\n// Receive-side serial bytes. Distinct from com's `serialData`, whose string->bytes\n// transform is for request bodies; events deliver raw byte arrays.\nconst rxBytes = v.array(v.pipe(v.number(), v.integer(), v.minValue(0), v.maxValue(255)));\n\n// Schema for the `data` payload of each event, keyed by the wire `type` literal.\nconst eventDataSchemas = {\n  'com.can_config': canConfig,\n  'com.rs232_config': rs232Config,\n  'com.rs485_config': rs485Config,\n  'com.spi_config': spiConfig,\n  'com.i2c_config': i2cConfig,\n  'com.uart_config': uartConfig,\n  'com.can_rx': v.array(canFrame),\n  'com.uart_rx': rxBytes,\n  'com.rs232_rx': rxBytes,\n  'com.rs485_rx': rxBytes,\n  'gpio.state': v.union([digitalState, analogState]),\n  'gpio.config': v.union([\n    analogInputConfiguration,\n    analogOutputConfiguration,\n    digitalInputConfiguration,\n    digitalOutputConfiguration,\n    openDrainConfiguration,\n  ]),\n  // Mirrors the glz::meta of gpio::sync_hold_state_t (apps/server/src/api/resources/gpio.hpp).\n  'gpio.sync': syncState,\n  'hmi.text': text,\n  'hmi.colors': color,\n  // `data` absent (progress hidden) is accepted by v.optional.\n  'hmi.progress': v.optional(progress),\n  'hmi.play': playbackConfiguration,\n  'hmi.knob': internalKnobEvent,\n  'management.datetime': v.object({ epoch_seconds: v.number() }),\n  'management.calibration': calibrationData,\n  'management.calibration_state': calibrationState,\n  'management.project': projectEvent,\n  'management.update_status': updateStatus,\n  'power.dut': dutState,\n  'power.usb': usbState,\n  'relays.state': relayState,\n  'relays.states': states,\n  'session.state': sessionState,\n} as const;\n\nconst dataLessEvents = [\n  'com.reset',\n  'gpio.reset',\n  'hmi.clear',\n  'hmi.reset',\n  'power.reset',\n  'relays.reset',\n] as const;\n\nconst envelope = v.object({\n  type: v.string(),\n  id: v.optional(v.pipe(v.number(), v.integer())),\n  ts: v.number(),\n  data: v.optional(v.unknown()),\n});\n\ntype EventDataSchemas = typeof eventDataSchemas;\n\n/** Every event `type` literal the server can emit. */\nexport type EventType = keyof EventDataSchemas | (typeof dataLessEvents)[number];\n\ntype PayloadEvent = {\n  [K in keyof EventDataSchemas]: {\n    type: K;\n    id?: number;\n    ts: number;\n    data: v.InferOutput<EventDataSchemas[K]>;\n  };\n}[keyof EventDataSchemas];\n\ntype DataLessEvent = { type: (typeof dataLessEvents)[number]; id?: number; ts: number };\n\n/** A fully-typed device event for a known `type`. */\nexport type DeviceEvent = PayloadEvent | DataLessEvent;\n\n/**\n * Shape delivered to `'*'` listeners. Forward-compatible: a newer server may emit\n * a `type` this SDK does not model, surfaced here with an untyped `data`.\n */\nexport type AnyDeviceEvent = DeviceEvent | {\n  type: string;\n  id?: number;\n  ts: number;\n  data?: unknown;\n};\n\ntype EventListener = (event: AnyDeviceEvent) => void;\ntype StateListener = (connected: boolean) => void;\n\nconst reconnectBaseDelayMs = 500;\nconst reconnectMaxDelayMs = 8_000;\nconst defaultConnectTimeoutMs = 5_000;\n\nconst debugLog = (...args: unknown[]): void => console.debug('[at1000:events]', ...args);\n\n/** @hideconstructor */\nexport class EventsApi {\n  private socket: WebSocket | undefined;\n  private readonly listeners = new Map<string, Set<EventListener>>();\n  private readonly stateListeners = new Set<StateListener>();\n  private shouldReconnect = false;\n  private reconnectDelayMs = reconnectBaseDelayMs;\n  private reconnectTimer: ReturnType<typeof setTimeout> | undefined;\n  private _connected = false;\n  private connectPromise: Promise<void> | undefined;\n\n  constructor(private readonly host: string) {}\n\n  /** Whether the WebSocket is currently open. */\n  get connected(): boolean {\n    return this._connected;\n  }\n\n  /**\n   * Open the event stream. Resolves once the socket is open, rejects on failure or\n   * after `timeout` ms. A no-op while already connected. Auto-reconnect arms only\n   * after the first successful open, so a failed initial `connect()` (e.g. old\n   * firmware without `/v0/events`) rejects without scheduling retries.\n   */\n  async connect(options?: { timeout?: number }): Promise<void> {\n    if (typeof WebSocket === 'undefined') {\n      throw new Error(\n        'WebSocket is not available in this runtime (Node >= 22, Bun, or a browser is required)',\n      );\n    }\n    if (this._connected) {\n      return;\n    }\n    // Coalesce concurrent opens: the layout holder-banner effect and the\n    // projects page both call connect() on the shared per-client socket. Without\n    // this a second caller starts a second openSocket() that orphans the first\n    // (leaked WS + a connect() that never settles). Reuse the in-flight open.\n    this.connectPromise ??= this.openSocket(options?.timeout ?? defaultConnectTimeoutMs);\n    try {\n      await this.connectPromise;\n    } finally {\n      this.connectPromise = undefined;\n    }\n  }\n\n  /** Close the stream and cancel any pending reconnect. */\n  close(): void {\n    this.shouldReconnect = false;\n    if (this.reconnectTimer !== undefined) {\n      clearTimeout(this.reconnectTimer);\n      this.reconnectTimer = undefined;\n    }\n    const socket = this.socket;\n    this.socket = undefined;\n    if (socket !== undefined) {\n      socket.close();\n    }\n    this.setConnected(false);\n  }\n\n  /**\n   * Subscribe to an event `type`, or `'*'` for every event. Returns an unsubscribe\n   * function. Listeners survive reconnects and are isolated: a throwing listener\n   * does not break dispatch to the others.\n   */\n  on<T extends EventType>(\n    type: T,\n    listener: (event: Extract<DeviceEvent, { type: T }>) => void,\n  ): () => void;\n  on(type: '*', listener: (event: AnyDeviceEvent) => void): () => void;\n  on(type: string, listener: (event: any) => void): () => void {\n    let set = this.listeners.get(type);\n    if (set === undefined) {\n      set = new Set();\n      this.listeners.set(type, set);\n    }\n    set.add(listener);\n    return () => {\n      const current = this.listeners.get(type);\n      if (current === undefined) {\n        return;\n      }\n      current.delete(listener);\n      if (current.size === 0) {\n        this.listeners.delete(type);\n      }\n    };\n  }\n\n  /** Subscribe to connection state changes. Returns an unsubscribe function. */\n  onStateChange(listener: StateListener): () => void {\n    this.stateListeners.add(listener);\n    return () => {\n      this.stateListeners.delete(listener);\n    };\n  }\n\n  private openSocket(timeoutMs: number): Promise<void> {\n    const { promise, resolve, reject } = Promise.withResolvers<void>();\n    const url = `ws://${format_host_for_url(this.host)}/v0/events`;\n    const socket = new WebSocket(url);\n    this.socket = socket;\n\n    let settled = false;\n    const timer = setTimeout(() => {\n      if (!settled) {\n        settled = true;\n        socket.close();\n        reject(new Error(`Timed out connecting to ${url}`));\n      }\n    }, timeoutMs);\n\n    socket.onopen = () => {\n      if (this.socket !== socket || settled) {\n        return;\n      }\n      settled = true;\n      clearTimeout(timer);\n      this.shouldReconnect = true;\n      this.reconnectDelayMs = reconnectBaseDelayMs;\n      this.setConnected(true);\n      debugLog('open', url);\n      resolve();\n    };\n\n    socket.onmessage = (event) => {\n      if (this.socket === socket) {\n        this.handleMessage(event.data);\n      }\n    };\n\n    socket.onerror = () => {\n      debugLog('error', url);\n      if (this.socket === socket && !settled) {\n        settled = true;\n        clearTimeout(timer);\n        reject(new Error(`Failed to connect to ${url}`));\n      }\n    };\n\n    socket.onclose = () => {\n      if (this.socket !== socket) {\n        return;\n      }\n      debugLog('close', url);\n      clearTimeout(timer);\n      this.setConnected(false);\n      if (!settled) {\n        settled = true;\n        reject(new Error(`Connection to ${url} closed before opening`));\n        return;\n      }\n      if (this.shouldReconnect) {\n        this.scheduleReconnect();\n      }\n    };\n\n    return promise;\n  }\n\n  private scheduleReconnect(): void {\n    if (!this.shouldReconnect || this.reconnectTimer !== undefined) {\n      return;\n    }\n    const delay = this.reconnectDelayMs;\n    debugLog('reconnecting in', delay, 'ms');\n    this.reconnectDelayMs = Math.min(this.reconnectDelayMs * 2, reconnectMaxDelayMs);\n    this.reconnectTimer = setTimeout(() => {\n      this.reconnectTimer = undefined;\n      if (!this.shouldReconnect) {\n        return;\n      }\n      // A failed attempt rejects this promise; onclose then schedules the next retry.\n      this.openSocket(defaultConnectTimeoutMs).catch(() => {});\n    }, delay);\n  }\n\n  private handleMessage(data: unknown): void {\n    if (typeof data !== 'string') {\n      debugLog('drop: non-string frame');\n      return;\n    }\n    let raw: unknown;\n    try {\n      raw = JSON.parse(data);\n    } catch {\n      debugLog('drop: invalid JSON', data);\n      return;\n    }\n\n    debugLog('recv', raw);\n    const parsed = v.safeParse(envelope, raw);\n    if (!parsed.success) {\n      debugLog('drop: malformed envelope', parsed.issues);\n      return;\n    }\n    const { type, id, ts } = parsed.output;\n\n    if (type in eventDataSchemas) {\n      const schema = eventDataSchemas[type as keyof EventDataSchemas] as v.GenericSchema;\n      const payload = v.safeParse(schema, parsed.output.data);\n      if (!payload.success) {\n        debugLog('drop: payload validation failed for', type, payload.issues);\n        return;\n      }\n      const event: AnyDeviceEvent = { type, id, ts, data: payload.output };\n      debugLog('dispatch', type);\n      this.emitTo(type, event);\n      this.emitTo('*', event);\n      return;\n    }\n\n    if ((dataLessEvents as readonly string[]).includes(type)) {\n      const event: AnyDeviceEvent = { type, id, ts };\n      debugLog('dispatch (dataless)', type);\n      this.emitTo(type, event);\n      this.emitTo('*', event);\n      return;\n    }\n\n    // Unknown type: deliver the raw envelope to '*' only (server may be newer).\n    debugLog('drop: unknown type', type);\n    this.emitTo('*', { type, id, ts, data: parsed.output.data });\n  }\n\n  private emitTo(key: string, event: AnyDeviceEvent): void {\n    const set = this.listeners.get(key);\n    if (set === undefined) {\n      return;\n    }\n    for (const listener of set) {\n      try {\n        listener(event);\n      } catch {\n        // One throwing listener must not break dispatch to the others.\n      }\n    }\n  }\n\n  private setConnected(connected: boolean): void {\n    if (this._connected === connected) {\n      return;\n    }\n    this._connected = connected;\n    for (const listener of this.stateListeners) {\n      try {\n        listener(connected);\n      } catch {\n        // Ignore throwing state listeners.\n      }\n    }\n  }\n}\n","import { type UpFetch, up } from 'up-fetch';\n\nimport { ComApi } from './api/com';\nimport { EventsApi } from './api/events';\nimport { GpioApi } from './api/gpio';\nimport { HmiApi } from './api/hmi';\nimport { type Information, ManagementApi } from './api/management';\nimport { PowerApi } from './api/power';\nimport { RelaysApi } from './api/relays';\nimport { SessionApi, open_session } from './api/session';\nimport { format_host_for_url } from './host';\n\n/** Structured error thrown for AT1000 API responses carrying `{ code, message, suggestion, path }`. */\nexport class ApiError extends Error {\n  readonly code: string;\n  /** Raw human-readable server message (without code/suggestion/path). */\n  readonly detail: string;\n  readonly suggestion: string;\n  readonly path: string;\n\n  constructor(body: { code: string; message: string; suggestion: string; path: string }) {\n    const formattedSuggestion = body.suggestion.replace(/\\n/g, '\\n                ');\n    super(\n      `${body.message} (${body.code})\\n    Suggestion: ${formattedSuggestion}\\n    Path: ${body.path}`,\n    );\n    this.code = body.code;\n    this.detail = body.message;\n    this.suggestion = body.suggestion;\n    this.path = body.path;\n  }\n}\n\n/** Type guard for the AT1000 structured error body. */\nfunction isApiErrorBody(\n  value: unknown,\n): value is { code: string; message: string; suggestion: string; path: string } {\n  if (typeof value !== 'object' || value === null) {\n    return false;\n  }\n  const record = value as Record<string, unknown>;\n  return ['code', 'message', 'suggestion', 'path'].every((key) => typeof record[key] === 'string');\n}\n\n/**\n * Shared rejection handler for every AT1000 up-fetch client. Parses a structured\n * `{ code, message, suggestion, path }` body into an {@link ApiError}, otherwise\n * throws a generic error carrying the HTTP status. Written once so the per-client\n * factory and `open_session` share one code path.\n */\nexport async function parseApiError(response: Response, method: string): Promise<never> {\n  let errorData: unknown;\n  const contentType = response.headers.get('content-type');\n  try {\n    errorData = contentType?.includes('application/json')\n      ? await response.json()\n      : await response.text();\n  } catch {\n    errorData = 'Failed to parse response body';\n  }\n\n  if (isApiErrorBody(errorData)) {\n    throw new ApiError(errorData);\n  }\n\n  throw new Error(\n    `API request to ${method} ${response.url} failed with status ${response.status}: ${\n      typeof errorData === 'string' ? errorData : JSON.stringify(errorData)\n    }`,\n  );\n}\n\n/** Options for opening a device. */\nexport interface OpenOptions {\n  /** Open read-only: skip `session/open`, mint no token, send no session header. */\n  readonly?: boolean;\n  /** Human-readable holder label shown to other clients and on the front panel. */\n  label?: string;\n}\n\n/** @hideconstructor */\nexport class AT1000Base {\n  /**\n   * IP address or hostname of the AT1000 device\n   */\n  public readonly host: string;\n  /**\n   * Device information\n   */\n  public readonly info: Information;\n  /**\n   * Session token minted by `open()`, or `undefined` for a read-only or legacy\n   * (pre-session) client. Sent as the `X-AT1000-Session` header on every request.\n   */\n  public readonly token: string | undefined;\n  /**\n   * `false` only when a pre-session server was detected during an exclusive\n   * `open()` (no `/v0/session/*` routes). Read-only opens never probe and report `true`.\n   */\n  public readonly sessionSupported: boolean;\n\n  private fetch: UpFetch;\n  /**\n   * COM API\n   */\n  public readonly com: ComApi;\n  /**\n   * HMI API\n   */\n  public readonly hmi: HmiApi;\n  /**\n   * GPIO API\n   */\n  public readonly gpio: GpioApi;\n  /**\n   * Management API\n   */\n  public readonly management: ManagementApi;\n  /**\n   * Power management API\n   */\n  public readonly power: PowerApi;\n  /**\n   * Relays API\n   */\n  public readonly relays: RelaysApi;\n  /**\n   * Real-time events API (WebSocket). Call `events.connect()` then `events.on(...)`.\n   */\n  public readonly events: EventsApi;\n  /**\n   * Session API. Read the current holder via `session.state()`.\n   */\n  public readonly session: SessionApi;\n\n  constructor(host: string, info: Information, token?: string, sessionSupported = true) {\n    this.host = host;\n    this.info = info;\n    this.token = token;\n    this.sessionSupported = sessionSupported;\n\n    this.fetch = up(\n      fetch,\n      () => ({\n        baseUrl: `http://${format_host_for_url(this.host)}/v0`,\n        timeout: 1000,\n        headers: this.token\n          ? { 'X-AT1000-Session': this.token }\n          : undefined,\n        parseRejected: (response, request) => parseApiError(response, request.method),\n      }),\n    );\n\n    this.com = new ComApi(this.fetch);\n    this.hmi = new HmiApi(this.fetch);\n    this.gpio = new GpioApi(this.fetch, this.info);\n    this.management = new ManagementApi(this.fetch, this.host);\n    this.power = new PowerApi(this.fetch, this.info);\n    this.relays = new RelaysApi(this.fetch);\n    this.events = new EventsApi(this.host);\n    this.session = new SessionApi(this.fetch);\n  }\n\n  async reset() {\n    await this.com.reset();\n    await this.hmi.reset();\n    await this.gpio.reset();\n    await this.power.reset();\n    await this.relays.reset();\n  }\n\n  protected static async openBase(\n    host: string,\n    options?: OpenOptions,\n    session?: { kind: 'remote' | 'project'; project?: string; defaultLabel?: string },\n  ): Promise<AT1000Base> {\n    if (!host?.trim()) {\n      throw new Error(\n        'No device address provided. Pass a host from findDevices() or findLocalDevice().',\n      );\n    }\n    const base = `http://${format_host_for_url(host)}/v0`;\n\n    // Re-fetch info to validate reachability (bare client, no session header yet).\n    const bare = up(\n      fetch,\n      () => ({\n        baseUrl: base,\n        timeout: 1000,\n        parseRejected: (response, request) =>\n          parseApiError(response, request.method),\n      }),\n    );\n    const info = await new ManagementApi(bare, host).info();\n\n    if (options?.readonly) {\n      return new AT1000Base(host, info);\n    }\n\n    const token = await open_session(base, {\n      kind: session?.kind ?? 'remote',\n      label: options?.label ?? session?.defaultLabel,\n      project: session?.project,\n    });\n    // `undefined` => pre-session server: keep a working, tokenless client.\n    return token === undefined\n      ? new AT1000Base(host, info, undefined, false)\n      : new AT1000Base(host, info, token);\n  }\n}\n"],"mappings":"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"}

package/build/events-Cf7iAMZP.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"events-Cf7iAMZP.d.cts","names":[],"sources":["../src/api/events.ts"],"mappings":";;cAiCM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAuCA;KAgBD,0BAA0B;;KAGnB,kBAAkB,2BAA2B;KAEpD,kBACF,WAAW;EACV,MAAM;EACN;EACA;EACA,MAAM,EAAE,YAAY,iBAAiB;WAEjC;KAEH;EAAkB,cAAc;EAAyB;EAAa;;;KAG/D,cAAc,eAAe;;;;;KAM7B,iBAAiB;EAC3B;EACA;EACA;EACA;;KAIG,iBAAiB;;cAST;mBAUkB;UATrB;mBACS;mBACA;UACT;UACA;UACA;UACA;UACA;EAEqB,YAAA;;MAGzB;;;;;;;EAUE,QAAQ;IAAY;MAAqB;;EAsB/C;;;;;;EAmBA,GAAG,UAAU,WACX,MAAM,GACN,WAAW,OAAO,QAAQ;IAAe,MAAM;;EAEjD,GAAG,WAAW,WAAW,OAAO;;EAqBhC,cAAc,UAAU;UAOhB;UA+DA;UAiBA;UAgDA;UAcA"}

package/build/events-Cf7iAMZP.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"events-Cf7iAMZP.d.mts","names":[],"sources":["../src/api/events.ts"],"mappings":";;cAiCM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAuCA;KAgBD,0BAA0B;;KAGnB,kBAAkB,2BAA2B;KAEpD,kBACF,WAAW;EACV,MAAM;EACN;EACA;EACA,MAAM,EAAE,YAAY,iBAAiB;WAEjC;KAEH;EAAkB,cAAc;EAAyB;EAAa;;;KAG/D,cAAc,eAAe;;;;;KAM7B,iBAAiB;EAC3B;EACA;EACA;EACA;;KAIG,iBAAiB;;cAST;mBAUkB;UATrB;mBACS;mBACA;UACT;UACA;UACA;UACA;UACA;EAEqB,YAAA;;MAGzB;;;;;;;EAUE,QAAQ;IAAY;MAAqB;;EAsB/C;;;;;;EAmBA,GAAG,UAAU,WACX,MAAM,GACN,WAAW,OAAO,QAAQ;IAAe,MAAM;;EAEjD,GAAG,WAAW,WAAW,OAAO;;EAqBhC,cAAc,UAAU;UAOhB;UA+DA;UAiBA;UAgDA;UAcA"}

package/build/gpio-Bk1VEKYF.d.cts

@@ -1,416 +0,0 @@
-import { t as AnalogOutputLevel } from "./common-Cv6nZZS9.cjs";
-import { Information } from "./management.cjs";
-import { UpFetch } from "up-fetch";
-import * as v from "valibot";
-//#region src/api/gpio.d.ts
-declare const analogInputConfiguration: v.ObjectSchema<{
-  readonly mode: v.LiteralSchema<"analog", undefined>;
-  readonly direction: v.LiteralSchema<"input", undefined>;
-}, undefined>;
-declare const analogOutputConfiguration: v.ObjectSchema<{
-  readonly mode: v.LiteralSchema<"analog", undefined>;
-  readonly direction: v.LiteralSchema<"output", undefined>;
-  readonly value: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 24, undefined>]>, undefined>;
-}, undefined>;
-/**
- * Input thresholds `vil` and `vih` are in [-25, 25] V, inclusive.
- */
-declare const digitalInputConfiguration: v.ObjectSchema<{
-  readonly mode: v.LiteralSchema<"digital", undefined>;
-  readonly direction: v.LiteralSchema<"input", undefined>;
-  readonly vil: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, -25, undefined>, v.MaxValueAction<number, 25, undefined>]>;
-  readonly vih: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, -25, undefined>, v.MaxValueAction<number, 25, undefined>]>;
-}, undefined>;
-/**
- * Readback thresholds `vil` and `vih` are in [-25, 25] V, inclusive.
- * Output levels `vol` and `voh` are in [0, 24] V, inclusive.
- */
-declare const digitalOutputConfiguration: v.ObjectSchema<{
-  readonly mode: v.LiteralSchema<"digital", undefined>;
-  readonly direction: v.LiteralSchema<"output", undefined>;
-  readonly value: v.SchemaWithPipe<readonly [v.UnionSchema<[v.BooleanSchema<undefined>, v.NumberSchema<undefined>], undefined>, v.ToBooleanAction<number | boolean>]>;
-  readonly vol: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 24, undefined>]>;
-  readonly voh: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 24, undefined>]>;
-  readonly vil: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, -25, undefined>, v.MaxValueAction<number, 25, undefined>]>;
-  readonly vih: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, -25, undefined>, v.MaxValueAction<number, 25, undefined>]>;
-}, undefined>;
-/**
- * Readback thresholds `vil` and `vih` are in [-25, 25] V, inclusive.
- */
-declare const openDrainConfiguration: v.ObjectSchema<{
-  readonly mode: v.LiteralSchema<"digital", undefined>;
-  readonly direction: v.LiteralSchema<"open_drain", undefined>;
-  readonly value: v.SchemaWithPipe<readonly [v.UnionSchema<[v.BooleanSchema<undefined>, v.NumberSchema<undefined>], undefined>, v.ToBooleanAction<number | boolean>]>;
-  readonly vil: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, -25, undefined>, v.MaxValueAction<number, 25, undefined>]>;
-  readonly vih: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, -25, undefined>, v.MaxValueAction<number, 25, undefined>]>;
-}, undefined>;
-type AnalogInputConfiguration = v.InferOutput<typeof analogInputConfiguration>;
-type AnalogOutputConfiguration = v.InferOutput<typeof analogOutputConfiguration>;
-type DigitalInputConfiguration = v.InferOutput<typeof digitalInputConfiguration>;
-type DigitalOutputConfiguration = v.InferOutput<typeof digitalOutputConfiguration>;
-type OpenDrainConfiguration = v.InferOutput<typeof openDrainConfiguration>;
-declare const partialAnalogOutputConfiguration: Omit<v.ObjectSchema<{
-  readonly mode: v.LiteralSchema<"analog", undefined>;
-  readonly direction: v.LiteralSchema<"output", undefined>;
-  readonly value: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 24, undefined>]>, undefined>;
-}, undefined>, "~types" | "~run" | "~standard" | "entries"> & {
-  readonly entries: Omit<{
-    readonly mode: v.LiteralSchema<"analog", undefined>;
-    readonly direction: v.LiteralSchema<"output", undefined>;
-    readonly value: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 24, undefined>]>, undefined>;
-  }, "mode" | "direction">;
-  readonly "~standard": v.StandardProps<{
-    value?: number | undefined;
-  }, {
-    value?: number | undefined;
-  }>;
-  readonly "~run": (dataset: v.UnknownDataset, config: v.Config<v.BaseIssue<unknown>>) => v.OutputDataset<{
-    value?: number | undefined;
-  }, v.NumberIssue | v.MinValueIssue<number, 0> | v.ObjectIssue | v.MaxValueIssue<number, 24>>;
-  readonly "~types"?: {
-    readonly input: {
-      value?: number | undefined;
-    };
-    readonly output: {
-      value?: number | undefined;
-    };
-    readonly issue: v.NumberIssue | v.MinValueIssue<number, 0> | v.ObjectIssue | v.MaxValueIssue<number, 24>;
-  } | undefined;
-};
-type PartialAnalogOutputConfiguration = v.InferOutput<typeof partialAnalogOutputConfiguration>;
-declare const partialDigitalInputConfiguration: Omit<v.ObjectSchema<{
-  readonly mode: v.LiteralSchema<"digital", undefined>;
-  readonly direction: v.LiteralSchema<"input", undefined>;
-  readonly vil: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, -25, undefined>, v.MaxValueAction<number, 25, undefined>]>;
-  readonly vih: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, -25, undefined>, v.MaxValueAction<number, 25, undefined>]>;
-}, undefined>, "~types" | "~run" | "~standard" | "entries"> & {
-  readonly entries: Omit<{
-    readonly mode: v.LiteralSchema<"digital", undefined>;
-    readonly direction: v.LiteralSchema<"input", undefined>;
-    readonly vil: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, -25, undefined>, v.MaxValueAction<number, 25, undefined>]>;
-    readonly vih: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, -25, undefined>, v.MaxValueAction<number, 25, undefined>]>;
-  }, "mode" | "direction">;
-  readonly "~standard": v.StandardProps<{
-    vil: number;
-    vih: number;
-  }, {
-    vil: number;
-    vih: number;
-  }>;
-  readonly "~run": (dataset: v.UnknownDataset, config: v.Config<v.BaseIssue<unknown>>) => v.OutputDataset<{
-    vil: number;
-    vih: number;
-  }, v.NumberIssue | v.ObjectIssue | v.MinValueIssue<number, -25> | v.MaxValueIssue<number, 25>>;
-  readonly "~types"?: {
-    readonly input: {
-      vil: number;
-      vih: number;
-    };
-    readonly output: {
-      vil: number;
-      vih: number;
-    };
-    readonly issue: v.NumberIssue | v.ObjectIssue | v.MinValueIssue<number, -25> | v.MaxValueIssue<number, 25>;
-  } | undefined;
-};
-type PartialDigitalInputConfiguration = v.InferOutput<typeof partialDigitalInputConfiguration>;
-declare const partialDigitalOutputConfiguration: Omit<Omit<v.ObjectSchema<{
-  readonly mode: v.LiteralSchema<"digital", undefined>;
-  readonly direction: v.LiteralSchema<"output", undefined>;
-  readonly value: v.SchemaWithPipe<readonly [v.UnionSchema<[v.BooleanSchema<undefined>, v.NumberSchema<undefined>], undefined>, v.ToBooleanAction<number | boolean>]>;
-  readonly vol: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 24, undefined>]>;
-  readonly voh: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 24, undefined>]>;
-  readonly vil: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, -25, undefined>, v.MaxValueAction<number, 25, undefined>]>;
-  readonly vih: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, -25, undefined>, v.MaxValueAction<number, 25, undefined>]>;
-}, undefined>, "~types" | "~run" | "~standard" | "entries"> & {
-  readonly entries: Omit<{
-    readonly mode: v.LiteralSchema<"digital", undefined>;
-    readonly direction: v.LiteralSchema<"output", undefined>;
-    readonly value: v.SchemaWithPipe<readonly [v.UnionSchema<[v.BooleanSchema<undefined>, v.NumberSchema<undefined>], undefined>, v.ToBooleanAction<number | boolean>]>;
-    readonly vol: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 24, undefined>]>;
-    readonly voh: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 24, undefined>]>;
-    readonly vil: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, -25, undefined>, v.MaxValueAction<number, 25, undefined>]>;
-    readonly vih: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, -25, undefined>, v.MaxValueAction<number, 25, undefined>]>;
-  }, "mode" | "direction">;
-  readonly "~standard": v.StandardProps<{
-    value: number | boolean;
-    vil: number;
-    vih: number;
-    vol: number;
-    voh: number;
-  }, {
-    value: boolean;
-    vil: number;
-    vih: number;
-    vol: number;
-    voh: number;
-  }>;
-  readonly "~run": (dataset: v.UnknownDataset, config: v.Config<v.BaseIssue<unknown>>) => v.OutputDataset<{
-    value: boolean;
-    vil: number;
-    vih: number;
-    vol: number;
-    voh: number;
-  }, v.BooleanIssue | v.NumberIssue | v.MinValueIssue<number, 0> | v.ObjectIssue | v.MinValueIssue<number, -25> | v.MaxValueIssue<number, 25> | v.MaxValueIssue<number, 24> | v.UnionIssue<v.BooleanIssue | v.NumberIssue>>;
-  readonly "~types"?: {
-    readonly input: {
-      value: number | boolean;
-      vil: number;
-      vih: number;
-      vol: number;
-      voh: number;
-    };
-    readonly output: {
-      value: boolean;
-      vil: number;
-      vih: number;
-      vol: number;
-      voh: number;
-    };
-    readonly issue: v.BooleanIssue | v.NumberIssue | v.MinValueIssue<number, 0> | v.ObjectIssue | v.MinValueIssue<number, -25> | v.MaxValueIssue<number, 25> | v.MaxValueIssue<number, 24> | v.UnionIssue<v.BooleanIssue | v.NumberIssue>;
-  } | undefined;
-}, "~types" | "~run" | "~standard" | "entries"> & {
-  readonly entries: {
-    readonly value: v.SchemaWithPipe<readonly [v.UnionSchema<[v.BooleanSchema<undefined>, v.NumberSchema<undefined>], undefined>, v.ToBooleanAction<number | boolean>]>;
-    readonly vil: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, -25, undefined>, v.MaxValueAction<number, 25, undefined>]>, undefined>;
-    readonly vih: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, -25, undefined>, v.MaxValueAction<number, 25, undefined>]>, undefined>;
-    readonly vol: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 24, undefined>]>;
-    readonly voh: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 24, undefined>]>;
-  };
-  readonly "~standard": v.StandardProps<{
-    value: number | boolean;
-    vil?: number | undefined;
-    vih?: number | undefined;
-    vol: number;
-    voh: number;
-  }, {
-    value: boolean;
-    vil?: number | undefined;
-    vih?: number | undefined;
-    vol: number;
-    voh: number;
-  }>;
-  readonly "~run": (dataset: v.UnknownDataset, config: v.Config<v.BaseIssue<unknown>>) => v.OutputDataset<{
-    value: boolean;
-    vil?: number | undefined;
-    vih?: number | undefined;
-    vol: number;
-    voh: number;
-  }, v.BooleanIssue | v.NumberIssue | v.MinValueIssue<number, 0> | v.ObjectIssue | v.MinValueIssue<number, -25> | v.MaxValueIssue<number, 25> | v.MaxValueIssue<number, 24> | v.UnionIssue<v.BooleanIssue | v.NumberIssue>>;
-  readonly "~types"?: {
-    readonly input: {
-      value: number | boolean;
-      vil?: number | undefined;
-      vih?: number | undefined;
-      vol: number;
-      voh: number;
-    };
-    readonly output: {
-      value: boolean;
-      vil?: number | undefined;
-      vih?: number | undefined;
-      vol: number;
-      voh: number;
-    };
-    readonly issue: v.BooleanIssue | v.NumberIssue | v.MinValueIssue<number, 0> | v.ObjectIssue | v.MinValueIssue<number, -25> | v.MaxValueIssue<number, 25> | v.MaxValueIssue<number, 24> | v.UnionIssue<v.BooleanIssue | v.NumberIssue>;
-  } | undefined;
-};
-type PartialDigitalOutputConfiguration = v.InferInput<typeof partialDigitalOutputConfiguration>;
-declare const partialOpenDrainConfiguration: Omit<v.ObjectSchema<{
-  readonly mode: v.LiteralSchema<"digital", undefined>;
-  readonly direction: v.LiteralSchema<"open_drain", undefined>;
-  readonly value: v.SchemaWithPipe<readonly [v.UnionSchema<[v.BooleanSchema<undefined>, v.NumberSchema<undefined>], undefined>, v.ToBooleanAction<number | boolean>]>;
-  readonly vil: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, -25, undefined>, v.MaxValueAction<number, 25, undefined>]>;
-  readonly vih: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, -25, undefined>, v.MaxValueAction<number, 25, undefined>]>;
-}, undefined>, "~types" | "~run" | "~standard" | "entries"> & {
-  readonly entries: Omit<{
-    readonly mode: v.LiteralSchema<"digital", undefined>;
-    readonly direction: v.LiteralSchema<"open_drain", undefined>;
-    readonly value: v.SchemaWithPipe<readonly [v.UnionSchema<[v.BooleanSchema<undefined>, v.NumberSchema<undefined>], undefined>, v.ToBooleanAction<number | boolean>]>;
-    readonly vil: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, -25, undefined>, v.MaxValueAction<number, 25, undefined>]>;
-    readonly vih: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, -25, undefined>, v.MaxValueAction<number, 25, undefined>]>;
-  }, "mode" | "direction">;
-  readonly "~standard": v.StandardProps<{
-    value: number | boolean;
-    vil: number;
-    vih: number;
-  }, {
-    value: boolean;
-    vil: number;
-    vih: number;
-  }>;
-  readonly "~run": (dataset: v.UnknownDataset, config: v.Config<v.BaseIssue<unknown>>) => v.OutputDataset<{
-    value: boolean;
-    vil: number;
-    vih: number;
-  }, v.BooleanIssue | v.NumberIssue | v.ObjectIssue | v.MinValueIssue<number, -25> | v.MaxValueIssue<number, 25> | v.UnionIssue<v.BooleanIssue | v.NumberIssue>>;
-  readonly "~types"?: {
-    readonly input: {
-      value: number | boolean;
-      vil: number;
-      vih: number;
-    };
-    readonly output: {
-      value: boolean;
-      vil: number;
-      vih: number;
-    };
-    readonly issue: v.BooleanIssue | v.NumberIssue | v.ObjectIssue | v.MinValueIssue<number, -25> | v.MaxValueIssue<number, 25> | v.UnionIssue<v.BooleanIssue | v.NumberIssue>;
-  } | undefined;
-};
-type PartialOpenDrainConfiguration = v.InferOutput<typeof partialOpenDrainConfiguration>;
-declare const digitalState: v.ObjectSchema<{
-  readonly value: v.SchemaWithPipe<readonly [v.UnionSchema<[v.BooleanSchema<undefined>, v.NumberSchema<undefined>], undefined>, v.ToBooleanAction<number | boolean>]>;
-}, undefined>;
-declare const analogState: v.ObjectSchema<{
-  readonly value: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, -25, undefined>, v.MaxValueAction<number, 25, undefined>]>;
-}, undefined>;
-declare const syncConfiguration: v.ObjectSchema<{
-  readonly action: v.PicklistSchema<["release", "hold"], "Invalid sync action">;
-}, undefined>;
-type SyncConfiguration = v.InferOutput<typeof syncConfiguration>;
-declare const syncState: v.ObjectSchema<{
-  readonly hold_state: v.PicklistSchema<["held", "released"], undefined>;
-}, undefined>;
-type SyncState = v.InferOutput<typeof syncState>;
-declare const gpioConfiguration: v.UnionSchema<[v.ObjectSchema<{
-  readonly mode: v.LiteralSchema<"digital", undefined>;
-  readonly direction: v.LiteralSchema<"output", undefined>;
-  readonly value: v.SchemaWithPipe<readonly [v.UnionSchema<[v.BooleanSchema<undefined>, v.NumberSchema<undefined>], undefined>, v.ToBooleanAction<number | boolean>]>;
-  readonly vol: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 24, undefined>]>;
-  readonly voh: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 24, undefined>]>;
-  readonly vil: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, -25, undefined>, v.MaxValueAction<number, 25, undefined>]>;
-  readonly vih: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, -25, undefined>, v.MaxValueAction<number, 25, undefined>]>;
-}, undefined>, v.ObjectSchema<{
-  readonly mode: v.LiteralSchema<"digital", undefined>;
-  readonly direction: v.LiteralSchema<"open_drain", undefined>;
-  readonly value: v.SchemaWithPipe<readonly [v.UnionSchema<[v.BooleanSchema<undefined>, v.NumberSchema<undefined>], undefined>, v.ToBooleanAction<number | boolean>]>;
-  readonly vil: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, -25, undefined>, v.MaxValueAction<number, 25, undefined>]>;
-  readonly vih: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, -25, undefined>, v.MaxValueAction<number, 25, undefined>]>;
-}, undefined>, v.ObjectSchema<{
-  readonly mode: v.LiteralSchema<"digital", undefined>;
-  readonly direction: v.LiteralSchema<"input", undefined>;
-  readonly vil: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, -25, undefined>, v.MaxValueAction<number, 25, undefined>]>;
-  readonly vih: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, -25, undefined>, v.MaxValueAction<number, 25, undefined>]>;
-}, undefined>, v.ObjectSchema<{
-  readonly mode: v.LiteralSchema<"analog", undefined>;
-  readonly direction: v.LiteralSchema<"output", undefined>;
-  readonly value: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 24, undefined>]>, undefined>;
-}, undefined>, v.ObjectSchema<{
-  readonly mode: v.LiteralSchema<"analog", undefined>;
-  readonly direction: v.LiteralSchema<"input", undefined>;
-}, undefined>], undefined>;
-type GpioConfiguration = v.InferOutput<typeof gpioConfiguration>;
-/** @hideconstructor */
-declare class GpioApi {
-  private readonly fetch;
-  private count;
-  constructor(fetch: UpFetch, info: Information);
-  /**
-   * Resets all IO configurations to default.
-   */
-  reset(): Promise<void>;
-  /**
-   * Access a specific digital IO pin by id.
-   * @param io The IO pin id.
-   * @returns The digital IO instance.
-   */
-  digital(io: number): DigitalIO;
-  /**
-   * Access a specific analog IO pin by id.
-   * @param io The IO pin id.
-   * @returns The analog IO instance.
-   */
-  analog(io: number): AnalogIO;
-  /**
-   * Holds the current state of all GPIO pins.
-   * @returns The applied sync state.
-   */
-  hold(): Promise<SyncConfiguration>;
-  /**
-   * Releases control of the IO pins, allowing external control.
-   *
-   * This also sets the device as a slave.
-   *
-   * @returns The applied sync state.
-   */
-  release(): Promise<SyncConfiguration>;
-  /**
-   * Reads back the current configuration of a specific IO pin.
-   * @param io The IO pin id.
-   * @returns The pin's current configuration.
-   */
-  read_config(io: number): Promise<GpioConfiguration>;
-  /**
-   * Reads the current hold state of all GPIO pins.
-   * @returns The current sync state.
-   */
-  read_sync(): Promise<SyncState>;
-}
-/** @hideconstructor */
-declare class DigitalIO {
-  private readonly fetch;
-  readonly id: number;
-  constructor(fetch: UpFetch, id: number);
-  /**
-   * Configure the pin as a digital input.
-   * @param config The digital input configuration.
-   * @returns The applied configuration.
-   */
-  configure_input(config: PartialDigitalInputConfiguration): Promise<DigitalInputConfiguration>;
-  /**
-   * Configures the pin as a digital output.
-   * @param config The digital output configuration.
-   * @returns The applied configuration.
-   */
-  configure_output(config: PartialDigitalOutputConfiguration): Promise<DigitalOutputConfiguration>;
-  /**
-   * Reads the current state of the pin.
-   * @returns The current state of the pin.
-   */
-  read(): Promise<boolean>;
-  /**
-   * Writes a value to the pin.
-   * @param value The value to write.
-   * @returns The written value.
-   */
-  write(value: boolean | number): Promise<boolean>;
-  /**
-   * Configure the pin as an open drain output.
-   * @param config The open drain configuration.
-   * @returns The applied configuration.
-   */
-  configure_open_drain(config: PartialOpenDrainConfiguration): Promise<OpenDrainConfiguration>;
-}
-/** @hideconstructor */
-declare class AnalogIO {
-  private readonly fetch;
-  readonly id: number;
-  constructor(fetch: UpFetch, id: number);
-  /**
-   * Configures the pin as an analog input.
-   * @returns The applied configuration.
-   * @returns The applied configuration.
-   */
-  configure_input(): Promise<AnalogInputConfiguration>;
-  /**
-   * Configures the pin as an analog output.
-   * @param config The analog output configuration.
-   * @returns The applied configuration.
-   */
-  configure_output(value: AnalogOutputLevel): Promise<AnalogOutputConfiguration>;
-  /**
-   * Reads the current state of the pin.
-   * @returns The current state of the pin.
-   */
-  read(): Promise<number>;
-  /**
-   * Writes a value to the pin.
-   * @param value The value to write.
-   * @returns The written value.
-   */
-  write(value: number): Promise<number>;
-}
-//#endregion
-export { openDrainConfiguration as C, gpioConfiguration as S, analogOutputConfiguration as _, DigitalInputConfiguration as a, digitalOutputConfiguration as b, GpioConfiguration as c, PartialDigitalInputConfiguration as d, PartialDigitalOutputConfiguration as f, analogInputConfiguration as g, SyncState as h, DigitalIO as i, OpenDrainConfiguration as l, SyncConfiguration as m, AnalogInputConfiguration as n, DigitalOutputConfiguration as o, PartialOpenDrainConfiguration as p, AnalogOutputConfiguration as r, GpioApi as s, AnalogIO as t, PartialAnalogOutputConfiguration as u, analogState as v, syncState as w, digitalState as x, digitalInputConfiguration as y };
-//# sourceMappingURL=gpio-Bk1VEKYF.d.cts.map

package/build/gpio-Bk1VEKYF.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"gpio-Bk1VEKYF.d.cts","names":[],"sources":["../src/api/gpio.ts"],"mappings":";;;;;cASa,0BAAwB,EAAA;;;;cAIxB,2BAAyB,EAAA;;;;;;;;cAQzB,2BAAyB,EAAA;;;;;;;;;;cAUzB,4BAA0B,EAAA;;;;;;;;;;;;cAY1B,wBAAsB,EAAA;;;;;;;KAOvB,2BAA2B,EAAE,mBAAmB;KAChD,4BAA4B,EAAE,mBAAmB;KACjD,4BAA4B,EAAE,mBAAmB;KACjD,6BAA6B,EAAE,mBAAmB;KAClD,yBAAyB,EAAE,mBAAmB;cAEpD,kCAAgC,KAAA,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAC1B,mCAAmC,EAAE,mBACxC;cAEH,kCAAgC,KAAA,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAC1B,mCAAmC,EAAE,mBACxC;cAEH,mCAAiC,KAAA,KAAA,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAI3B,oCAAoC,EAAE,kBACzC;cAEH,+BAA6B,KAAA,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KACvB,gCAAgC,EAAE,mBAAmB;cAEpD,cAAY,EAAA;;;cACZ,aAAW,EAAA;;;cAElB,mBAAiB,EAAA;mBAAjB,EAAA;;KACM,oBAAoB,EAAE,mBAAmB;cAExC,WAAS,EAAA;uBAAT,EAAA;;KACD,YAAY,EAAE,mBAAmB;cAEhC,mBAAiB,EAAA,aAAA,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;KAOlB,oBAAoB,EAAE,mBAAmB;;cAGxC;mBAGkB;UAFrB;EAEqB,YAAA,OAAO,SAAS,MAAM;;;;EAOnD,SAAS;;;;;;EAST,QAAQ,aAAa;;;;;;EAiBrB,OAAO,aAAa;;;;;EAgBpB,QAAQ,QAAQ;;;;;;;;EAehB,WAAW,QAAQ;;;;;;EAanB,YAAY,aAAa,QAAQ;;;;;EAgBjC,aAAa,QAAQ;;;cAMV;mBACkB;WAAgC;EAAhC,YAAA,OAAO,SAAyB;;;;;;EAO7D,gBAAgB,QAAQ,mCAAmC,QAAQ;;;;;;EAgBnE,iBAAiB,QAAQ,oCAAoC,QAAQ;;;;;EAwB/D,QAAQ;;;;;;EASR,MAAM,0BAA0B;;;;;;EActC,qBAAqB,QAAQ,gCAAgC,QAAQ;;;cAa1D;mBACkB;WAAgC;EAAhC,YAAA,OAAO,SAAyB;;;;;;EAO7D,mBAAmB,QAAQ;;;;;;EAa3B,iBAAiB,OAAO,oBAAoB,QAAQ;;;;;EAe9C,QAAQ;;;;;;EASR,MAAM,gBAAgB"}