dimcode-darwin-x64 0.1.0-alpha.17 → 0.1.0-alpha.19

package/plugins/goal/node_modules/@arcships/rutis/src/testing.mjs

@@ -1,350 +0,0 @@
-// 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/goal/node_modules/@arcships/rutis/src/values.mjs

@@ -1,261 +0,0 @@
-// 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/goal/node_modules/zod/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2025 Colin McDonnell
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.