dimcode-darwin-x64 0.1.0-alpha.14 → 0.1.0-alpha.16

package/plugins/session-title/node_modules/@arcships/rutis/src/testing.mjs

@@ -0,0 +1,350 @@
+// Test a plugin on a real host: give it the services it injects, call the
+// services it provides, unload it.
+//
+//   const t = await load(plugin, { config: { city: 'Oslo' }, services: { llm } })
+//   assert.equal(await t.service('weather').today(), 'sunny in Oslo')
+//   assert.equal(await t.serial('weather/ask', 'Oslo'), 'sunny')
+//   await t.unload()
+//
+// Several plugins on one `host()`:
+//
+//   const h = host({ services: { llm } })
+//   const chat = await h.load(chatPlugin)
+//   await h.parallel('session/created', id)
+//
+// The plugin runs in the real runtime (`@arcships/rutis-runtime`, or
+// `@arcships/rutis-bun` under Bun) of a real host (`rutis-host test`:
+// RUTIS_HOST, else the project's `@arcships/rutis-host`, else the one on
+// PATH), started once per test process (platform cleanup
+// §7.5): the host checks its config and fills its defaults, gates it on
+// the services it injects, and dispatches its events; what crosses between
+// it and the test crosses between processes. The test's listeners (`on`)
+// and what it emits are those of a plugin next to it in the same runtime,
+// the test tool's own; each of the test's services is a row of its own
+// there. The plugin is loaded from its
+// module, which must export it as default.
+
+import { createRequire } from 'node:module'
+import { join } from 'node:path'
+import { pathToFileURL } from 'node:url'
+import { PLUGIN_API, isPlugin } from './advanced.mjs'
+
+export class PluginTestError extends Error {
+  name = 'PluginTestError'
+}
+
+const FILE = Symbol.for('rutis.plugin-file')
+
+// What the test serves the driver: its services' methods, by the
+// service's name, and its listeners, by `listener:<id>`.
+const served = new Map()
+let nextListener = 0
+function dispatch(target, method, args) {
+  const object = served.get(target)
+  if (object === undefined) throw new Error(`${target} is gone`)
+  return target.startsWith('listener:') ? object(...args) : object[method](...args)
+}
+
+// `specifier` as the project in the current directory resolves it, as a
+// file URL, if it does.
+function fromProject(specifier) {
+  try {
+    return pathToFileURL(createRequire(join(process.cwd(), 'package.json')).resolve(specifier)).href
+  } catch {
+    return undefined
+  }
+}
+
+// The host and runtime of this process, started at the first `load`.
+let started
+function runtime() {
+  started ??= (async () => {
+    const bun = typeof globalThis.Bun !== 'undefined'
+    const name = bun ? '@arcships/rutis-bun' : '@arcships/rutis-runtime'
+    // The project's runtime (a dev dependency of the project, not of this
+    // package), else one this package can import.
+    let start
+    try {
+      ({ start } = await import(fromProject(`${name}/testing`) ?? `${name}/testing`))
+    } catch (error) {
+      if (error?.code !== 'ERR_MODULE_NOT_FOUND' && error?.code !== 'MODULE_NOT_FOUND' && !/Cannot find (module|package)/.test(error?.message)) throw error
+      throw new PluginTestError(`the test tool runs plugins in ${name}: add it as a dev dependency`)
+    }
+    const harness = await start({ dispatch, outgoing: hold })
+    harness.control.unref()
+    held = harness.control
+    return harness.control
+  })()
+  return started
+}
+
+// `testEnded(fn)`: `fn` runs when the test running now ends, passed or
+// failed (a timeout too): node:test's `after`, under `node --test`, or
+// Bun's `onTestFinished`, under `bun test`. For the calls of a test
+// (hold) and the hosts it makes (host).
+let testEnded
+if (typeof globalThis.Bun !== 'undefined') {
+  const { onTestFinished } = await import('bun:test')
+  // Outside a test (a file's top level, `beforeAll`), Bun has no test to
+  // end: nothing runs.
+  testEnded = fn => { try { onTestFinished(fn) } catch {} }
+} else if (process.env.NODE_TEST_CONTEXT || process.execArgv.includes('--test')) {
+  ({ after: testEnded } = await import('node:test'))
+}
+
+// The driver, synchronously (the test waits) or not.
+let control
+// While an asynchronous call of this process is out (a service's method,
+// a function or promise a plugin handed over), the session keeps the
+// process running, until its reply comes or the test that made it ends
+// (it failed at its timeout, say; testEnded): node:test reports and exits
+// once nothing keeps the process running.
+let held
+let out = 0
+function hold() {
+  let holding = true
+  if (out++ === 0) held?.ref()
+  const release = () => {
+    if (!holding) return
+    holding = false
+    if (--out === 0) held?.unref()
+  }
+  testEnded?.(release)
+  return release
+}
+// `target`: the driver itself (''), or a service by its name.
+const NOT_STARTED = 'the host starts at the first load: load a plugin first'
+function call(method, ...args) {
+  if (!control) throw new PluginTestError(NOT_STARTED)
+  return control.call('', method, args)
+}
+function ask(method, ...args) {
+  return askOf('', method, args)
+}
+async function askOf(target, method, args) {
+  if (!control) throw new PluginTestError(NOT_STARTED)
+  return control.callAsync(target, method, args)
+}
+
+// The methods rutis sees on a service no declaration describes: its own
+// and inherited functions, up to Object's, not the constructor.
+function methodNames(object) {
+  const names = new Set()
+  for (let level = object; level != null && level !== Object.prototype && level !== Function.prototype; level = Object.getPrototypeOf(level)) {
+    for (const name of Object.getOwnPropertyNames(level)) {
+      if (name !== 'constructor' && typeof Object.getOwnPropertyDescriptor(level, name)?.value === 'function') names.add(name)
+    }
+  }
+  return [...names]
+}
+
+// The test's services `services`, provided next to the plugins; the
+// function that withdraws them.
+async function provide(services) {
+  const names = []
+  try {
+    for (const [name, object] of Object.entries(services)) {
+      served.set(name, object)
+      names.push(name)
+      await ask('provide', name, methodNames(object))
+    }
+  } catch (error) {
+    await withdraw(names)
+    throw error
+  }
+  return () => withdraw(names)
+}
+async function withdraw(names) {
+  for (const name of names.reverse()) {
+    served.delete(name)
+    await ask('withdraw', name)
+  }
+}
+
+// The five ways to emit and `filter`, from the test's plugin; `keep`, the
+// filter.
+function emitters(keep) {
+  // `<mode>(name, ...values)`, or `filter.<mode>(keep, name, ...values)`.
+  const method = mode => keep ? [`filter.${mode}`, keep] : [mode]
+  const sync = mode => (...args) => call(...method(mode), ...args)
+  const async = mode => (...args) => ask(...method(mode), ...args)
+  return {
+    emit: (...args) => { sync('emit')(...args) },
+    parallel: async('parallel'),
+    serial: async('serial'),
+    waterfall: Object.assign(async('waterfall'), {
+      with: terminal => {
+        if (typeof terminal !== 'function') throw new PluginTestError('waterfall.with needs a terminal function')
+        return (...args) => async('waterfall.with')(terminal, ...args)
+      },
+    }),
+    bail: sync('bail'),
+    filter: predicate => {
+      if (typeof predicate !== 'function') throw new PluginTestError('filter needs a predicate function')
+      const { filter: _, ...five } = emitters(predicate)
+      return five
+    },
+  }
+}
+
+// The module that exports `plugin` as default, as a real runtime loads it.
+async function fileOf(plugin) {
+  const file = plugin[FILE]
+  let module
+  try {
+    module = file && await import(file)
+  } catch {}
+  if (module?.default !== plugin) {
+    throw new PluginTestError(`load needs a plugin that its module exports as default${file ? `: ${file} does not` : ''}`)
+  }
+  return file
+}
+
+/**
+ * Plugins on the host, sharing its bus. `services` are the test's, given
+ * to every plugin that injects them. Not unloaded when the test that made
+ * it ends (it failed before `unload`, say), it unloads then: the next test
+ * finds none of its rows or services.
+ */
+export function host({ services = {} } = {}) {
+  const rows = []
+  let withdrawShared
+  let closed = false
+  const self = {
+    /** The failures the host reported of the rows here (§5.6): `{ line }`. */
+    async reported() { return (await Promise.all(rows.map(row => row.api.reported()))).flat() },
+    /**
+     * Load `plugin` as a row, with `config` and its own `services`; `id`,
+     * the row's id; `isolate`, as a row's (`{ forecast: true }` or a label).
+     */
+    async load(plugin, { config, services: own = {}, id: rowId, isolate } = {}) {
+      if (closed) throw new PluginTestError('the host is unloaded')
+      plugin = isPlugin(plugin) ? plugin : plugin?.default
+      if (!isPlugin(plugin)) throw new PluginTestError('load needs a plugin made with definePlugin')
+      if (plugin.api > PLUGIN_API) {
+        throw new PluginTestError(`the plugin needs plugin API ${plugin.api}; this SDK supports ${PLUGIN_API}`)
+      }
+      const file = await fileOf(plugin)
+      control = await runtime()
+      withdrawShared ??= await provide(services)
+      const withdrawOwn = await provide(own)
+      let id
+      try {
+        id = await ask('load', file, config ?? null, { ...(rowId === undefined ? {} : { id: rowId }), ...(isolate === undefined ? {} : { isolate }) })
+      } catch (error) {
+        await withdrawOwn()
+        throw new PluginTestError(error?.message ?? String(error))
+      }
+      const row = loaded(id, plugin, withdrawOwn)
+      rows.push(row)
+      return row.api
+    },
+    /** Unload every row, latest first. */
+    async unload() {
+      closed = true
+      for (const row of [...rows].reverse()) await row.unload()
+      await withdrawShared?.()
+      withdrawShared = undefined
+    },
+    ...emitters(undefined),
+  }
+  testEnded?.(() => self.unload())
+
+  function loaded(id, plugin, withdrawOwn) {
+    // This row's test listeners: withdrawn when it unloads.
+    const mine = new Set()
+    let unloaded = false
+    const shape = name => {
+      if (!call('provided', id).includes(name)) throw new PluginTestError(`the plugin does not provide ${name} (now)`)
+      return plugin.provides[name] ?? call('methods', name)
+    }
+    // Unload the row as the host does, then withdraw its services and the
+    // test's listeners of it.
+    const unload = async () => {
+      if (unloaded) return
+      unloaded = true
+      rows.splice(rows.indexOf(record), 1)
+      await ask('unload', id)
+      for (const off of [...mine]) off()
+      await withdrawOwn()
+    }
+    const api = {
+      /** The row's id on the host. */
+      row: id,
+      /** The service `name` the plugin provides, as rutis sees it: its declared methods, or, undeclared, the object's methods, all async. */
+      service(name) {
+        if (unloaded) throw new PluginTestError('the plugin is unloaded')
+        return Object.fromEntries(Object.entries(shape(name)).map(([method, kind]) => [method, kind === 'sync'
+          ? (...args) => control.call(name, method, args)
+          : (...args) => askOf(name, method, args)]))
+      },
+      /** The methods rutis sees on the service `name`: `{ method: 'sync' | 'async' }`. */
+      methods: name => ({ ...shape(name) }),
+      /** The names of the services the plugin provides now. */
+      provided: () => call('provided', id),
+      /**
+       * The failures the host reported of this row (a listener failing in an
+       * `emit`, a filter): `{ line }`, `line` as the host prints it.
+       */
+      async reported() { return unloaded ? [] : (await ask('reported', id)).map(line => ({ line })) },
+      /** The host this row is loaded on. */
+      host: self,
+      ...emitters(undefined),
+      /**
+       * Listen to the event `name` as a plugin next to it does, until the
+       * returned function is called or the row unloads. Options as
+       * `ctx.on`: `prepend`, `global`.
+       */
+      on(name, listener, options) {
+        if (unloaded) throw new PluginTestError('the plugin is unloaded')
+        if (typeof listener !== 'function') throw new PluginTestError('on needs a listener function')
+        const target = `listener:${++nextListener}`
+        served.set(target, listener)
+        try {
+          call('on', target, name, { prepend: Boolean(options?.prepend), global: Boolean(options?.global) })
+        } catch (error) {
+          served.delete(target)
+          throw error
+        }
+        const off = () => {
+          if (!mine.delete(off)) return
+          served.delete(target)
+          call('off', target)
+        }
+        mine.add(off)
+        return off
+      },
+      /** Change the row's config, as a host does. */
+      async update(config) {
+        if (unloaded) throw new PluginTestError('the plugin is unloaded')
+        try {
+          await ask('update', id, config ?? null)
+        } catch (error) {
+          throw new PluginTestError(error?.message ?? String(error))
+        }
+      },
+      /** Unload the row as the host does, then withdraw its services and the test's listeners of it. */
+      unload,
+    }
+    const record = { api, unload }
+    return record
+  }
+
+  return self
+}
+
+/**
+ * Load `plugin` (what definePlugin returns, or a module whose default export
+ * it is) with `config` and the services in `services`, on a `host()` of its
+ * own.
+ */
+export async function load(plugin, { config, services = {} } = {}) {
+  const h = host({ services })
+  const t = await h.load(plugin, { config }).catch(async error => {
+    await h.unload()
+    throw error
+  })
+  // Unloading it unloads its host too, with the test's services.
+  t.unload = () => h.unload()
+  return t
+}

package/plugins/session-title/node_modules/@arcships/rutis/src/values.mjs

@@ -0,0 +1,261 @@
+// The tagged values beyond JSON data (#308, #355, #360): a point in time,
+// a local date and time, a date, a time of day, binary data, a map, a set,
+// a big integer, a decimal and a UUID. Each crosses a session under its own
+// tag, as text in the formats below, and only to a far end that declared
+// the capability `value-<tag>`.
+//
+// | tag        | JavaScript sends        | receives     | text on the wire                     |
+// | ---------- | ----------------------- | ------------ | ------------------------------------ |
+// | `instant`  | `Date`                  | `Date`       | `2026-10-15T03:22:15.123Z`, UTC      |
+// | `datetime` | `rutis.datetime(text)`  | string       | `2026-10-15T14:30:05.25`, no zone    |
+// | `date`     | `rutis.date(text)`      | string       | `2026-10-15`                         |
+// | `time`     | `rutis.time(text)`      | string       | `14:30:05.25`, 24-hour, no zone      |
+// | `bytes`    | `Uint8Array` (`Buffer`), `ArrayBuffer`, `DataView` | `Uint8Array` | base64, padded |
+// | `map`      | `Map`                   | `Map`        | `[[key, value], …]`, in order        |
+// | `set`      | `Set`                   | `Set`        | `[element, …]`, in order             |
+// | `bigint`   | `bigint`                | `bigint`     | decimal integer, at most 4300 digits |
+// | `decimal`  | `rutis.decimal(text)`   | string       | `-12.3400`, trailing zeros kept      |
+// | `uuid`     | `rutis.uuid(text)`      | string       | lowercase `8-4-4-4-12` hex           |
+//
+// Years are 0001–9999; fractions of a second have 0–9 digits; an instant is
+// truncated to the millisecond toward negative infinity when received. The
+// constructors at the end make objects marked with
+// `Symbol.for('rutis.value')`, so the runtimes know them without importing
+// this package; the testing tool crosses values by the same rules. This is
+// the SDK's own copy of the runtimes' rules (node/rutis-runtime/src/
+// values.mjs). Design: docs/design-value-types-2026-10-15.md; the
+// normative wire text is in docs/design-protocol-plugins-2026-09-25.md
+// §6.1; the Rust reference is crates/rutis-bridge/src/session/values.rs.
+
+// The mark on what the SDK constructors make: `{ [MARK]: tag, value: text }`.
+export const MARK = Symbol.for('rutis.value')
+// The tags the SDK constructors make; the rest are JavaScript values.
+const CONSTRUCTED = ['datetime', 'date', 'time', 'decimal', 'uuid']
+// The most digits a bigint or decimal may have: Python's default limit on
+// integer text.
+export const MAX_DIGITS = 4300
+
+// A value this side cannot send or take: only the call carrying it fails,
+// the session goes on (unlike a frame not in the protocol's shape).
+export class ValueError extends TypeError {}
+
+// A text a value error quotes, shortened to 40 characters.
+const quoted = text => text.length > 40 ? `${JSON.stringify(text.slice(0, 40))}…` : JSON.stringify(text)
+const invalid = (what, text, expected) => new ValueError(`invalid ${what} ${quoted(text)}: expected ${expected}`)
+
+// ── The text formats ──────────────────────────────────────────────────
+
+const DATE = /^(\d{4})-(\d{2})-(\d{2})$/
+const TIME = /^(\d{2}):(\d{2}):(\d{2})(?:\.(\d{1,9}))?$/
+
+const leap = year => year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0)
+const daysInMonth = (year, month) => month === 2 ? (leap(year) ? 29 : 28) : [4, 6, 9, 11].includes(month) ? 30 : 31
+
+// `[year, month, day]` of `YYYY-MM-DD`, a day of years 0001–9999.
+function readDate(text) {
+  const match = DATE.exec(text)
+  if (!match) return undefined
+  const [year, month, day] = match.slice(1).map(Number)
+  if (year < 1 || month < 1 || month > 12 || day < 1 || day > daysInMonth(year, month)) return undefined
+  return [year, month, day]
+}
+// `[hour, minute, second, fraction digits]` of `HH:MM:SS[.f…]`.
+function readTime(text) {
+  const match = TIME.exec(text)
+  if (!match) return undefined
+  const [hour, minute, second] = match.slice(1, 4).map(Number)
+  if (hour > 23 || minute > 59 || second > 59) return undefined
+  return [hour, minute, second, match[4] ?? '']
+}
+// `[date, time]` of `YYYY-MM-DDTHH:MM:SS[.f…]`.
+function readDateTime(text) {
+  const at = text.indexOf('T')
+  if (at !== 10) return undefined
+  const date = readDate(text.slice(0, 10)), time = readTime(text.slice(11))
+  return date && time ? [date, time] : undefined
+}
+
+// Days from 1970-01-01 to `year-month-day` (H. Hinnant's `days_from_civil`).
+function daysFromCivil(year, month, day) {
+  year -= month <= 2 ? 1 : 0
+  const era = Math.floor(year / 400)
+  const yearOfEra = year - era * 400
+  const dayOfYear = Math.floor((153 * ((month + 9) % 12) + 2) / 5) + day - 1
+  const dayOfEra = yearOfEra * 365 + Math.floor(yearOfEra / 4) - Math.floor(yearOfEra / 100) + dayOfYear
+  return era * 146097 + dayOfEra - 719468
+}
+
+// 0001-01-01T00:00:00Z and 9999-12-31T23:59:59.999Z, in milliseconds.
+const FIRST_MS = -62135596800000
+const LAST_MS = 253402300799999
+
+// Checks of each text, as the wire takes it.
+const formats = {
+  instant: text => text.endsWith('Z') && readDateTime(text.slice(0, -1)) ? undefined : 'RFC 3339 in UTC, YYYY-MM-DDTHH:MM:SS[.fraction]Z, years 0001–9999',
+  datetime: text => readDateTime(text) ? undefined : 'YYYY-MM-DDTHH:MM:SS[.fraction] without a time zone, years 0001–9999',
+  date: text => readDate(text) ? undefined : 'YYYY-MM-DD, years 0001–9999',
+  time: text => readTime(text) ? undefined : 'HH:MM:SS[.fraction], 24-hour, 0–9 fraction digits',
+  bigint: text => /^-?(0|[1-9]\d*)$/.test(text) && text !== '-0' && text.replace('-', '').length <= MAX_DIGITS ? undefined : `a decimal integer without leading zeros, at most ${MAX_DIGITS} digits`,
+  decimal: text => /^-?(0|[1-9]\d*)(\.\d+)?$/.test(text) && text.replace(/[-.]/g, '').length <= MAX_DIGITS ? undefined : `decimal digits with an optional fraction, no exponent, at most ${MAX_DIGITS} digits`,
+  uuid: text => /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/.test(text) ? undefined : 'lowercase hex 8-4-4-4-12',
+}
+
+// `text`, if it is a valid `tag` value; else a ValueError.
+export function checkText(tag, text) {
+  if (typeof text !== 'string') throw new ValueError(`invalid ${tag}: expected its text, not ${describe(text)}`)
+  const expected = formats[tag](text)
+  if (expected) throw invalid(tag, text, expected)
+  return text
+}
+
+// The Date an instant's text names, truncated to the millisecond toward
+// negative infinity (design V7).
+export function instantFromText(text) {
+  checkText('instant', text)
+  const [[year, month, day], [hour, minute, second, fraction]] = readDateTime(text.slice(0, -1))
+  const seconds = daysFromCivil(year, month, day) * 86400 + hour * 3600 + minute * 60 + second
+  return new Date(seconds * 1000 + Number(fraction.padEnd(3, '0').slice(0, 3)))
+}
+
+// A Date's text as an instant; a ValueError for an invalid Date or one
+// outside years 0001–9999.
+export function instantText(date) {
+  const time = date.getTime()
+  if (Number.isNaN(time)) throw new ValueError('cannot send an invalid Date')
+  if (time < FIRST_MS || time > LAST_MS) throw new ValueError(`cannot send the Date ${date.toISOString()}: an instant is within years 0001–9999`)
+  // `YYYY-MM-DDTHH:MM:SS.sssZ`, without trailing zeros in the fraction.
+  return date.toISOString().replace(/\.?0*Z$/, 'Z')
+}
+
+// ── Binary data ──────────────────────────────────────────────────────
+
+// The bytes of a Uint8Array, ArrayBuffer or DataView (a Buffer is a
+// Uint8Array); undefined for anything else.
+export function bytesOf(value) {
+  if (value instanceof Uint8Array) return value
+  if (value instanceof ArrayBuffer) return new Uint8Array(value)
+  if (value instanceof DataView) return new Uint8Array(value.buffer, value.byteOffset, value.byteLength)
+  return undefined
+}
+
+// ── What crosses as a tagged value ───────────────────────────────────
+
+// The tag of an SDK constructor's value, if `value` is one.
+export const constructedTag = value => value !== null && typeof value === 'object' && CONSTRUCTED.includes(value[MARK]) ? value[MARK] : undefined
+
+// The tag `value` crosses under, if it crosses as a tagged value. Other
+// typed arrays (Int16Array, ...) are not bytes: their element type would
+// be lost.
+export function tagOf(value) {
+  if (typeof value === 'bigint') return 'bigint'
+  if (value === null || typeof value !== 'object') return undefined
+  if (value instanceof Date) return 'instant'
+  if (value instanceof Map) return 'map'
+  if (value instanceof Set) return 'set'
+  if (bytesOf(value)) return 'bytes'
+  return constructedTag(value)
+}
+
+// What `value` is, for errors.
+export function describe(value) {
+  if (value === null) return 'null'
+  if (value === undefined) return 'undefined'
+  if (Array.isArray(value)) return 'an array'
+  const tag = tagOf(value)
+  if (tag) return { instant: 'a Date', bytes: 'binary data', map: 'a Map', set: 'a Set', bigint: 'a bigint' }[tag] ?? `a ${tag}`
+  if (ArrayBuffer.isView(value)) return `a ${value.constructor.name}`
+  if (typeof value === 'object') return 'an object'
+  return `a ${typeof value}`
+}
+
+// ── Map keys and set elements (design §5) ────────────────────────────
+
+// The fraction of a time without trailing zeros: `14:30:05.250` and
+// `14:30:05.25` are one time.
+const shortTime = text => text.replace(/(\.\d*?)0+$/, '$1').replace(/\.$/, '')
+
+const unsafeKey = (what, number) => new ValueError(`a ${what} cannot be the integer ${number}, beyond ±(2^53-1): send it as a bigint`)
+const refusedKey = (what, kind) => new ValueError(`a ${what} cannot be ${kind}: only strings, finite numbers, booleans, bigint, datetime, date, time, decimal and uuid values can (an instant, bytes, null, an array, an object, a map, a set or a reference cannot)`)
+
+// How a key compares with the others of its map (`what` "map key") or set
+// ("set element"), as `tag` and its JavaScript value: numbers by value (0
+// and -0 are one), the rest by kind and text. A ValueError for a value
+// that is not a key in every language.
+export function keyIdentity(tag, value, what) {
+  switch (tag) {
+    case 'data':
+      if (typeof value === 'string') return `s${value}`
+      if (typeof value === 'boolean') return `b${value}`
+      if (typeof value === 'number') {
+        if (!Number.isFinite(value)) throw refusedKey(what, String(value))
+        // Beyond ±(2^53−1) two integers may be one double: send a bigint.
+        if (Number.isInteger(value) && !Number.isSafeInteger(value)) throw unsafeKey(what, value)
+        return `n${value === 0 ? 0 : value}`
+      }
+      throw refusedKey(what, describe(value))
+    case 'bigint': return `bigint${value}`
+    case 'datetime': case 'time': return `${tag}${shortTime(value)}`
+    case 'date': case 'decimal': case 'uuid': return `${tag}${value}`
+    default: throw refusedKey(what, tag === 'instant' ? 'an instant' : describe(value))
+  }
+}
+
+// A key or element this side sends, as `[tag, value]` for keyIdentity:
+// an SDK constructor's value as its tag and checked text.
+export function keyOf(value) {
+  const constructed = constructedTag(value)
+  if (constructed) return [constructed, checkText(constructed, value.value)]
+  if (value === null || typeof value === 'object' || typeof value === 'function' || value === undefined) return [tagOf(value) ?? 'other', value]
+  return [typeof value === 'bigint' ? 'bigint' : 'data', value]
+}
+
+// Each `[tag, value]` of `keys` a key, no two equal (a language that merged
+// them would lose an entry); then none equal once received in JavaScript
+// (`received`, the Map or Set made), where a date, decimal or ... is its
+// text and may meet a string key.
+export function checkKeys(keys, what, received) {
+  const seen = new Set()
+  for (const [tag, value] of keys) {
+    const identity = keyIdentity(tag, value, what)
+    if (seen.has(identity)) throw new ValueError(`duplicate ${what} ${shownKey(value)}: a map or set whose keys collide would lose entries`)
+    seen.add(identity)
+  }
+  if (received && received.size !== seen.size) {
+    throw new ValueError(`duplicate ${what} once received: two ${what}s are one key in JavaScript (a datetime, date, time, decimal or uuid arrives as its text), so an entry would be lost`)
+  }
+}
+
+function shownKey(value) {
+  const text = typeof value === 'string' ? JSON.stringify(value) : String(value)
+  return text.length > 40 ? `${text.slice(0, 40)}…` : text
+}
+
+// ── The constructors ─────────────────────────────────────────────────
+
+// A local date and time, date, time of day, decimal or UUID: JavaScript
+// has no type for them, so a plugin receives them as strings and sends
+// them as one of these. A string stays a string.
+class Value {
+  constructor(tag, text) {
+    this[MARK] = tag
+    this.value = text
+    Object.freeze(this)
+  }
+  toString() { return this.value }
+  toJSON() { return this.value }
+}
+
+const make = (tag, text) => new Value(tag, checkText(tag, text))
+// `HH:MM` as `HH:MM:00`: the wire always has seconds.
+const withSeconds = text => typeof text === 'string' ? text.replace(/(^|T)(\d{2}:\d{2})$/, '$1$2:00') : text
+
+/** A local date and time without a time zone (`datetime`): `'2026-10-15T14:30'`, `'2026-10-15T14:30:05.25'`. */
+export const datetime = text => make('datetime', withSeconds(text))
+/** A calendar date (`date`): `'2026-10-15'`. */
+export const date = text => make('date', text)
+/** A time of day without a time zone (`time`): `'14:30'`, `'14:30:05.25'`. */
+export const time = text => make('time', withSeconds(text))
+/** A decimal number (`decimal`), its trailing zeros kept: `'1.10'`, `'-12.3400'`; a bigint is taken as its digits. */
+export const decimal = text => make('decimal', typeof text === 'bigint' ? String(text) : text)
+/** A UUID (`uuid`), in either case; sent in lowercase. */
+export const uuid = text => make('uuid', typeof text === 'string' ? text.toLowerCase() : text)

package/plugins/session-title/package-lock.json

@@ -0,0 +1,45 @@
+{
+  "name": "@dimcode/session-title",
+  "version": "0.1.0",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "@dimcode/session-title",
+      "version": "0.1.0",
+      "dependencies": {
+        "@arcships/rutis": "0.19.3"
+      },
+      "devDependencies": {
+        "@types/node": "24.10.0"
+      }
+    },
+    "node_modules/@arcships/rutis": {
+      "version": "0.19.3",
+      "resolved": "https://registry.npmjs.org/@arcships/rutis/-/rutis-0.19.3.tgz",
+      "integrity": "sha512-mpeVQ2tIZFyiKibgmRtyEhFu0NW3xam/OMUWSkddXIj8a/QqyW3AiE37GKlb4ihpHtuRx1dIz9HyCYHgvnecJw==",
+      "license": "MIT",
+      "engines": {
+        "bun": ">=1.4",
+        "node": ">=22"
+      }
+    },
+    "node_modules/@types/node": {
+      "version": "24.10.0",
+      "resolved": "https://registry.npmjs.org/@types/node/-/node-24.10.0.tgz",
+      "integrity": "sha512-qzQZRBqkFsYyaSWXuEHc2WR9c0a0CXwiE5FWUvn7ZM+vdy1uZLfCunD38UzhuB7YN/J11ndbDBcTmOdxJo9Q7A==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "undici-types": "~7.16.0"
+      }
+    },
+    "node_modules/undici-types": {
+      "version": "7.16.0",
+      "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-7.16.0.tgz",
+      "integrity": "sha512-Zz+aZWSj8LE6zoxD+xrjh4VfkIG8Ya6LvYkZqtUQGJPZjYl53ypCaUwWqo7eI0x66KBGeRo+mlBEkMSeSZ38Nw==",
+      "dev": true,
+      "license": "MIT"
+    }
+  }
+}

package/plugins/session-title/package.json

@@ -0,0 +1,9 @@
+{
+  "name": "@dimcode/session-title",
+  "private": true,
+  "version": "0.1.0",
+  "type": "module",
+  "exports": "./index.ts",
+  "dependencies": { "@arcships/rutis": "0.19.3" },
+  "devDependencies": { "@types/node": "24.10.0" }
+}