@query-farm/vgi 0.6.0

package/dist/worker.d.ts

@@ -0,0 +1,36 @@
+import type { VgiFunction } from "./functions/types.js";
+import type { CatalogDescriptor } from "./catalog/descriptors.js";
+import type { CatalogInterface } from "./catalog/interface.js";
+import { ReadOnlyCatalogInterface } from "./catalog/read-only.js";
+export interface WorkerConfig {
+    functions?: VgiFunction[];
+    catalog?: CatalogDescriptor;
+    catalogInterface?: CatalogInterface;
+    /** Factory that receives the built ReadOnlyCatalogInterface and returns a custom catalog. */
+    catalogInterfaceFactory?: (base: ReadOnlyCatalogInterface) => CatalogInterface;
+    catalogName?: string;
+}
+export declare class Worker {
+    private _registry;
+    private _catalogInterface?;
+    private _catalogName?;
+    constructor(config: WorkerConfig);
+    run(argv?: readonly string[]): void;
+    /** Build the VGI protocol from this worker's registry + catalog interface. */
+    private buildProtocol;
+    /**
+     * Serve this worker over a caller-provided byte-stream pair, instead of the
+     * argv-selected stdio/unix/tcp transports `run()` uses. Resolves when the
+     * `readable` ends.
+     *
+     * This is the seam for transports that aren't a process/socket — most notably
+     * a **Web Worker**: bridge the worker's `MessagePort` to a Node `Duplex`
+     * (readable side ← `port.on('message')`, writable side → `port.postMessage`)
+     * and pass it as both arguments. The same code runs in a browser Web Worker.
+     *
+     * @param readable incoming request bytes (web `ReadableStream` or Node `Readable`).
+     * @param writable outgoing response sink (a `net.Socket`/`Duplex`, or an fd
+     *   number). Omit for the stdout fd.
+     */
+    serveStream(readable: ReadableStream<Uint8Array> | NodeJS.ReadableStream, writable?: number | import("node:net").Socket): Promise<void>;
+}

package/package.json

@@ -0,0 +1,96 @@
+{
+  "name": "@query-farm/vgi",
+  "version": "0.6.0",
+  "description": "TypeScript framework for extending DuckDB with user-defined functions via the Vector Gateway Interface (VGI) over Arrow IPC.",
+  "license": "SEE LICENSE IN LICENSE",
+  "author": "Query Farm LLC (https://query.farm)",
+  "homepage": "https://github.com/Query-farm/vgi-typescript#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Query-farm/vgi-typescript.git"
+  },
+  "bugs": {
+    "url": "https://github.com/Query-farm/vgi-typescript/issues"
+  },
+  "keywords": [
+    "duckdb",
+    "arrow",
+    "vgi",
+    "query-farm",
+    "udf",
+    "user-defined-function",
+    "hyperfederation",
+    "extension"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=22.15"
+  },
+  "type": "module",
+  "sideEffects": false,
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "workerd": "./src/index.ts",
+      "worker": "./src/index.ts",
+      "browser": "./src/index.ts",
+      "bun": "./src/index.ts",
+      "import": "./dist/index.js"
+    },
+    "./client": {
+      "types": "./dist/client-entry.d.ts",
+      "bun": "./src/client-entry.ts",
+      "import": "./dist/client-entry.js"
+    },
+    "./worker-cf": {
+      "types": "./dist/worker-cf-entry.d.ts",
+      "workerd": "./src/worker-cf-entry.ts",
+      "worker": "./src/worker-cf-entry.ts",
+      "browser": "./src/worker-cf-entry.ts",
+      "bun": "./src/worker-cf-entry.ts",
+      "import": "./dist/worker-cf-entry.js"
+    }
+  },
+  "files": [
+    "dist",
+    "src",
+    "!src/**/__tests__/**",
+    "!src/**/*.test.ts",
+    "!src/**/*.spec.ts"
+  ],
+  "imports": {
+    "#arrow-impl": {
+      "workerd": "./src/arrow/impl-flechette/index.ts",
+      "worker": "./src/arrow/impl-flechette/index.ts",
+      "default": "./src/arrow/impl-arrowjs/index.ts"
+    }
+  },
+  "dependencies": {
+    "@noble/ciphers": "^2.2.0",
+    "@query-farm/flechette": "^2.4.0"
+  },
+  "peerDependencies": {
+    "@query-farm/apache-arrow": "^21.1.1",
+    "@query-farm/vgi-rpc": "^0.9.0"
+  },
+  "devDependencies": {
+    "@duckdb/node-api": "^1.5.2-r.1",
+    "@query-farm/apache-arrow": "^21.1.1",
+    "@query-farm/vgi-rpc": "^0.9.0",
+    "@types/bun": "latest",
+    "typescript": "^6.0.3"
+  },
+  "scripts": {
+    "build": "bun run build:types && bun run build:js",
+    "prepack": "bun run build",
+    "build:types": "bunx tsc -p tsconfig.build.json",
+    "build:js": "bun build ./src/index.ts --outdir dist --target node --format esm --sourcemap=external --external @query-farm/apache-arrow --external @query-farm/vgi-rpc && bun build ./src/client-entry.ts --outdir dist --target browser --format esm --sourcemap=external --external @query-farm/apache-arrow --external @query-farm/vgi-rpc && bun build ./src/worker-cf-entry.ts --outdir dist --target node --format esm --sourcemap=external --external @query-farm/apache-arrow --external @query-farm/vgi-rpc",
+    "postinstall": "node scripts/postinstall.cjs",
+    "build:browser-test": "bun build examples/browser/main.ts --outdir examples/browser/dist --target browser --format esm --sourcemap=external",
+    "test": "bun test"
+  }
+}

package/src/arguments/argument-spec.ts

@@ -0,0 +1,200 @@
+// Copyright 2025, 2026 Query Farm LLC - https://query.farm
+// ArgumentSpec: converts function argument definitions to Arrow schema with VGI metadata keys.
+// Must produce byte-identical schemas to Python's argument_specs_to_schema().
+
+import { type VgiSchema, schema as schema_, type VgiField, field as field_, type VgiDataType, nullType, deserializeBatch } from "../arrow/index.js";
+import {
+  VGI_ARG_KEY,
+  VGI_ARG_NAMED,
+  VGI_TYPE_KEY,
+  VGI_TYPE_TABLE,
+  VGI_TYPE_ANY,
+  VGI_VARARGS_KEY,
+  VGI_VARARGS_TRUE,
+  VGI_CONST_KEY,
+  VGI_CONST_TRUE,
+  VGI_DOC_KEY,
+} from "../types.js";
+
+export interface ArgumentSpec {
+  name: string;
+  position: number | string;
+  arrowType: VgiDataType;
+  isTableInput?: boolean;
+  isAnyType?: boolean;
+  isVarargs?: boolean;
+  isConst?: boolean;
+  doc?: string;
+}
+
+function argumentSpecSortKey(spec: ArgumentSpec): [number, number | string] {
+  if (typeof spec.position === "number") {
+    return [0, spec.position];
+  }
+  return [1, spec.position];
+}
+
+/**
+ * Convert ArgumentSpecs to an Arrow Schema with VGI metadata keys.
+ * Positional arguments come first (in order), named arguments follow.
+ */
+export function argumentSpecsToSchema(specs: ArgumentSpec[]): VgiSchema {
+  const sorted = [...specs].sort((a, b) => {
+    const ka = argumentSpecSortKey(a);
+    const kb = argumentSpecSortKey(b);
+    if (ka[0] !== kb[0]) return ka[0] - kb[0];
+    if (typeof ka[1] === "number" && typeof kb[1] === "number") {
+      return ka[1] - kb[1];
+    }
+    return String(ka[1]).localeCompare(String(kb[1]));
+  });
+
+  const fields: VgiField[] = [];
+  for (const spec of sorted) {
+    const metadata: Map<string, string> = new Map();
+
+    if (typeof spec.position === "string") {
+      metadata.set(VGI_ARG_KEY, VGI_ARG_NAMED);
+    }
+
+    if (spec.isTableInput) {
+      metadata.set(VGI_TYPE_KEY, VGI_TYPE_TABLE);
+    } else if (spec.isAnyType) {
+      metadata.set(VGI_TYPE_KEY, VGI_TYPE_ANY);
+    }
+
+    if (spec.isVarargs) {
+      metadata.set(VGI_VARARGS_KEY, VGI_VARARGS_TRUE);
+    }
+
+    if (spec.isConst) {
+      metadata.set(VGI_CONST_KEY, VGI_CONST_TRUE);
+    }
+
+    // Per-argument description (UTF-8; presence-only — omit when empty).
+    if (spec.doc) {
+      metadata.set(VGI_DOC_KEY, spec.doc);
+    }
+
+    const field = field_(
+      spec.name,
+      spec.arrowType,
+      true,
+      metadata.size > 0 ? metadata : undefined
+    );
+    fields.push(field);
+  }
+
+  return schema_(fields);
+}
+
+// =============================================================================
+// Macro Argument Schemas
+// =============================================================================
+
+/**
+ * Build a macro `arguments_schema` describing macro parameters.
+ *
+ * Mirrors the function `arguments_schema` mechanism: one Arrow field per macro
+ * parameter, in `parameters` order, each nullable. The per-parameter
+ * description is carried via the same `vgi_doc` field-metadata key functions use
+ * (UTF-8, presence-only — the key is omitted entirely when there is no doc). A
+ * parameter's field type is the type of its default value when one is known
+ * (decoded from `parameterDefaultValues`, a one-row RecordBatch serialized as
+ * IPC bytes), else `nullType()`.
+ *
+ * @param parameters Ordered list of macro parameter names.
+ * @param parameterDefaultValues Optional one-row RecordBatch (IPC bytes) whose
+ *   columns are parameter names with typed default values; used to infer each
+ *   parameter's field type.
+ * @param parameterDocs Optional mapping of parameter name to description. Empty
+ *   or missing descriptions yield no `vgi_doc` metadata on the field.
+ * @returns Arrow schema with one nullable field per parameter, in order.
+ */
+export function macroArgumentsSchema(
+  parameters: string[],
+  parameterDefaultValues?: Uint8Array | null,
+  parameterDocs?: Record<string, string>,
+): VgiSchema {
+  const docs = parameterDocs ?? {};
+
+  // Map parameter name -> Arrow type from the typed default values, if any.
+  const defaultTypes: Map<string, VgiDataType> = new Map();
+  if (parameterDefaultValues && parameterDefaultValues.length > 0) {
+    const batch = deserializeBatch(parameterDefaultValues);
+    for (const f of batch.schema.fields) {
+      defaultTypes.set(f.name, f.type);
+    }
+  }
+
+  const fields: VgiField[] = [];
+  for (const name of parameters) {
+    const metadata: Map<string, string> = new Map();
+    const doc = docs[name];
+    if (doc) {
+      metadata.set(VGI_DOC_KEY, doc);
+    }
+    const fieldType = defaultTypes.get(name) ?? nullType();
+    fields.push(field_(name, fieldType, true, metadata.size > 0 ? metadata : undefined));
+  }
+
+  return schema_(fields);
+}
+
+/**
+ * Extract per-parameter descriptions from a macro `arguments_schema`.
+ *
+ * Inverse of {@link macroArgumentsSchema}'s `vgi_doc` handling: reads the
+ * `vgi_doc` field metadata (UTF-8) for each field. Fields without the key
+ * (undocumented) are omitted from the result.
+ *
+ * @param schema A macro `arguments_schema` (one field per parameter).
+ * @returns Mapping of parameter name to description, for documented parameters only.
+ */
+export function macroParameterDocsFromSchema(schema: VgiSchema): Record<string, string> {
+  const docs: Record<string, string> = {};
+  for (const field of schema.fields) {
+    const doc = field.metadata.get(VGI_DOC_KEY);
+    if (doc) {
+      docs[field.name] = doc;
+    }
+  }
+  return docs;
+}
+
+/**
+ * Convert an Arrow Schema back to ArgumentSpecs.
+ */
+export function schemaToArgumentSpecs(schema: VgiSchema): ArgumentSpec[] {
+  const specs: ArgumentSpec[] = [];
+  let positionIndex = 0;
+
+  for (const field of schema.fields) {
+    const metadata = field.metadata;
+
+    const isNamed = metadata.get(VGI_ARG_KEY) === VGI_ARG_NAMED;
+    const position: number | string = isNamed
+      ? field.name
+      : positionIndex++;
+
+    const vgiType = metadata.get(VGI_TYPE_KEY);
+    const isTableInput = vgiType === VGI_TYPE_TABLE;
+    const isAnyType = vgiType === VGI_TYPE_ANY;
+    const isVarargs = metadata.get(VGI_VARARGS_KEY) === VGI_VARARGS_TRUE;
+    const isConst = metadata.get(VGI_CONST_KEY) === VGI_CONST_TRUE;
+    const doc = metadata.get(VGI_DOC_KEY) ?? "";
+
+    specs.push({
+      name: field.name,
+      position,
+      arrowType: field.type,
+      isTableInput,
+      isAnyType,
+      isVarargs,
+      isConst,
+      doc,
+    });
+  }
+
+  return specs;
+}

package/src/arguments/arguments.ts

@@ -0,0 +1,81 @@
+// Copyright 2025, 2026 Query Farm LLC - https://query.farm
+// Arguments container for VGI function invocations.
+// Holds positional and named scalar values from DuckDB.
+
+import type { VgiSchema } from "../arrow/index.js";
+import { safeNumber } from "../util/arrow/index.js";
+
+export class Arguments {
+  readonly positional: (any | null)[];
+  readonly named: Map<string, any | null>;
+  /** Schema of the arguments batch (preserves original Arrow types). */
+  readonly argumentsSchema: VgiSchema | null;
+
+  constructor(
+    positional: (any | null)[] = [],
+    named: Map<string, any | null> = new Map(),
+    argumentsSchema: VgiSchema | null = null,
+  ) {
+    this.positional = positional;
+    this.named = named;
+    this.argumentsSchema = argumentsSchema;
+  }
+
+  /**
+   * Get an argument by position (number) or name (string).
+   */
+  get(position: number | string, defaultValue?: any): any {
+    if (typeof position === "number") {
+      if (position < this.positional.length) {
+        const val = this.positional[position];
+        if (val === null || val === undefined) {
+          return defaultValue !== undefined ? defaultValue : null;
+        }
+        return unwrapScalar(val);
+      }
+      if (defaultValue !== undefined) return defaultValue;
+      throw new Error(`Positional argument ${position} not found`);
+    }
+    if (this.named.has(position)) {
+      const val = this.named.get(position);
+      if (val === null || val === undefined) {
+        return defaultValue !== undefined ? defaultValue : null;
+      }
+      return unwrapScalar(val);
+    }
+    if (defaultValue !== undefined) return defaultValue;
+    throw new Error(`Named argument '${position}' not found`);
+  }
+
+  get length(): number {
+    return this.positional.length;
+  }
+}
+
+/**
+ * Unwrap an Arrow Scalar to a plain JS value.
+ */
+function unwrapScalar(val: any): any {
+  if (val === null || val === undefined) return null;
+  // If it's already a primitive, return it
+  if (typeof val !== "object") return val;
+  // Arrow Scalar objects have a valueOf() method
+  if (typeof val.valueOf === "function") {
+    let v: any;
+    try {
+      v = val.valueOf();
+    } catch {
+      // valueOf() may throw for large Decimal values (e.g. HUGEINT)
+      return val;
+    }
+    // BigInt -> Number for safe integers
+    if (typeof v === "bigint") {
+      if (v >= Number.MIN_SAFE_INTEGER && v <= Number.MAX_SAFE_INTEGER) {
+        return Number(v);
+      }
+      return v;
+    }
+    return v;
+  }
+  return val;
+}

package/src/arrow/codec/branded.ts

@@ -0,0 +1,206 @@
+// Copyright 2025, 2026 Query Farm LLC - https://query.farm
+//
+// Branded "raw" scalar types — phase 3.
+//
+// The `raw` representation is a branded view layered directly on top of the
+// CANONICAL value (see ./registry.ts). A branded raw value is, at runtime,
+// exactly the underlying canonical primitive (a `number` or a `bigint`); the
+// brand exists only at the type level so the compiler can distinguish, say, a
+// `Date32` (days since epoch) from a plain `number` or a `TimestampMicros`
+// (raw us) from a plain `bigint`. This carries the WIRE UNIT in the type and
+// makes a wrong-unit mix-up a compile error in `raw` mode.
+//
+// Constructors (`asDate32`, `asTimestampMicros`, …) validate the underlying
+// value by reusing the codec's validation (so a raw constructor enforces the
+// same range/integrality rules as building a column) and then brand it.
+// Unwrappers (`fromBranded`) strip the brand back to the plain primitive; they
+// are identity at runtime.
+//
+// Rich mode (the phase-1 default) uses JS `Date` for date32/date64 and plain
+// number/bigint everywhere else. Raw mode replaces those with the branded
+// aliases below so every temporal/decimal/64-bit-int slot is unit-tagged.
+
+import {
+  int32 as int32Type,
+  int64 as int64Type,
+  uint64 as uint64Type,
+  decimal128 as decimal128Type,
+  TimeUnit,
+} from "../schema-types.js";
+import { codecFor } from "./registry.js";
+
+// ---------------------------------------------------------------------------
+// Brand machinery
+// ---------------------------------------------------------------------------
+
+declare const __brand: unique symbol;
+
+/** A nominal brand over a base primitive. `Branded<number, 'date32'>` is a
+ *  `number` at runtime but a distinct type at compile time. */
+export type Branded<Base, Tag extends string> = Base & {
+  readonly [__brand]: Tag;
+};
+
+// ---------------------------------------------------------------------------
+// Branded scalar aliases (over the CANONICAL value, carrying unit info)
+// ---------------------------------------------------------------------------
+
+/** date32 raw: days since the Unix epoch. */
+export type Date32 = Branded<number, "date32">;
+/** date64 raw: milliseconds since the Unix epoch. */
+export type Date64Ms = Branded<bigint, "date64ms">;
+
+/** time32[s] raw: seconds since midnight. */
+export type Time32S = Branded<number, "time32s">;
+/** time32[ms] raw: milliseconds since midnight. */
+export type Time32Ms = Branded<number, "time32ms">;
+/** time64[us] raw: microseconds since midnight. */
+export type Time64Us = Branded<bigint, "time64us">;
+/** time64[ns] raw: nanoseconds since midnight. */
+export type Time64Ns = Branded<bigint, "time64ns">;
+
+/** timestamp[s] raw. */
+export type TimestampSeconds = Branded<bigint, "ts_s">;
+/** timestamp[ms] raw. */
+export type TimestampMillis = Branded<bigint, "ts_ms">;
+/** timestamp[us] raw. */
+export type TimestampMicros = Branded<bigint, "ts_us">;
+/** timestamp[ns] raw. */
+export type TimestampNanos = Branded<bigint, "ts_ns">;
+
+/** duration[s] raw. */
+export type DurationSeconds = Branded<bigint, "dur_s">;
+/** duration[ms] raw. */
+export type DurationMillis = Branded<bigint, "dur_ms">;
+/** duration[us] raw. */
+export type DurationMicros = Branded<bigint, "dur_us">;
+/** duration[ns] raw. */
+export type DurationNanos = Branded<bigint, "dur_ns">;
+
+/** A decimal's UNSCALED integer (the on-wire representation). */
+export type UnscaledDecimal = Branded<bigint, "decimal_unscaled">;
+
+/** int64 raw. (Rich int64 is already a plain bigint; the brand makes the
+ *  declared width explicit in raw mode.) */
+export type Int64 = Branded<bigint, "int64">;
+/** uint64 raw. */
+export type Uint64 = Branded<bigint, "uint64">;
+
+// ---------------------------------------------------------------------------
+// Validation-reusing constructors
+// ---------------------------------------------------------------------------
+
+// One codec instance per branded type, reused for validation. `richToCanonical`
+// is the validating canonical-producer; for these scalar types rich===canonical
+// (except date, which the raw constructor sidesteps by validating the numeric
+// directly), so this is exactly the right range/integrality check.
+
+const dec128Codec = codecFor(decimal128Type(38, 0));
+
+/** Validate `n` against int32 integrality/range, returning it unbranded. */
+function validateInt32(n: number): number {
+  codecFor(int32Type()).richToCanonical(n);
+  return n;
+}
+
+function validateBigInt(
+  codecType: ReturnType<typeof int64Type> | ReturnType<typeof uint64Type>,
+  b: bigint,
+): bigint {
+  codecFor(codecType).richToCanonical(b);
+  return b;
+}
+
+/** date32 days: validated as a 32-bit integer day-number, then branded. */
+export function asDate32(days: number): Date32 {
+  if (!Number.isInteger(days)) {
+    throw new TypeError(`asDate32: expected an integer day-number, got ${days}`);
+  }
+  return validateInt32(days) as Date32;
+}
+
+/** date64 ms: validated as a 64-bit integer, then branded. */
+export function asDate64Ms(ms: bigint): Date64Ms {
+  return validateBigInt(int64Type(), ms) as unknown as Date64Ms;
+}
+
+function asTime32(label: string, n: number): number {
+  if (!Number.isInteger(n)) {
+    throw new TypeError(`${label}: expected an integer, got ${n}`);
+  }
+  return validateInt32(n);
+}
+
+/** time32[s]. */
+export const asTime32S = (n: number): Time32S => asTime32("asTime32S", n) as Time32S;
+/** time32[ms]. */
+export const asTime32Ms = (n: number): Time32Ms => asTime32("asTime32Ms", n) as Time32Ms;
+
+/** time64[us]. */
+export const asTime64Us = (b: bigint): Time64Us =>
+  validateBigInt(int64Type(), b) as unknown as Time64Us;
+/** time64[ns]. */
+export const asTime64Ns = (b: bigint): Time64Ns =>
+  validateBigInt(int64Type(), b) as unknown as Time64Ns;
+
+/** timestamp[s]. */
+export const asTimestampSeconds = (b: bigint): TimestampSeconds =>
+  validateBigInt(int64Type(), b) as unknown as TimestampSeconds;
+/** timestamp[ms]. */
+export const asTimestampMillis = (b: bigint): TimestampMillis =>
+  validateBigInt(int64Type(), b) as unknown as TimestampMillis;
+/** timestamp[us]. */
+export const asTimestampMicros = (b: bigint): TimestampMicros =>
+  validateBigInt(int64Type(), b) as unknown as TimestampMicros;
+/** timestamp[ns]. */
+export const asTimestampNanos = (b: bigint): TimestampNanos =>
+  validateBigInt(int64Type(), b) as unknown as TimestampNanos;
+
+/** duration[s]. */
+export const asDurationSeconds = (b: bigint): DurationSeconds =>
+  validateBigInt(int64Type(), b) as unknown as DurationSeconds;
+/** duration[ms]. */
+export const asDurationMillis = (b: bigint): DurationMillis =>
+  validateBigInt(int64Type(), b) as unknown as DurationMillis;
+/** duration[us]. */
+export const asDurationMicros = (b: bigint): DurationMicros =>
+  validateBigInt(int64Type(), b) as unknown as DurationMicros;
+/** duration[ns]. */
+export const asDurationNanos = (b: bigint): DurationNanos =>
+  validateBigInt(int64Type(), b) as unknown as DurationNanos;
+
+/** A decimal's unscaled integer (validated as a bigint, then branded). */
+export function asUnscaledDecimal(unscaled: bigint): UnscaledDecimal {
+  dec128Codec.richToCanonical(unscaled);
+  return unscaled as unknown as UnscaledDecimal;
+}
+
+/** int64 (validated for signed 64-bit range). */
+export const asInt64 = (b: bigint): Int64 =>
+  validateBigInt(int64Type(), b) as unknown as Int64;
+/** uint64 (validated for unsigned 64-bit range). */
+export const asUint64 = (b: bigint): Uint64 =>
+  validateBigInt(uint64Type(), b) as unknown as Uint64;
+
+// ---------------------------------------------------------------------------
+// Unwrappers — strip the brand back to the plain primitive (identity at runtime)
+// ---------------------------------------------------------------------------
+
+/** Strip a numeric brand, returning the plain `number`. */
+export function fromBrandedNumber(v: Branded<number, string>): number {
+  return v as number;
+}
+
+/** Strip a bigint brand, returning the plain `bigint`. */
+export function fromBrandedBigInt(v: Branded<bigint, string>): bigint {
+  return v as bigint;
+}
+
+/** Generic unbrand for either base type. */
+export function fromBranded<Base, Tag extends string>(v: Branded<Base, Tag>): Base {
+  return v as Base;
+}
+
+// Re-export TimeUnit for callers that want to pick a timestamp/duration unit
+// when constructing facade types alongside branded values.
+export { TimeUnit };