@prestack/thread 0.1.3 → 0.1.5

package/dist/integrations/module.ts

@@ -1,191 +0,0 @@
-import { spawnSync } from 'node:child_process'
-import { argv, stderr, stdout } from 'node:process'
-
-import type { Env } from '../core/actor.ts'
-import { answer, asking, given, unasked, wordsIn } from '../core/answers.ts'
-import { readFileSync } from '../core/files.ts'
-import { exit } from '../core/invoked.ts'
-import { valuesIn } from '../core/rows.ts'
-import { findTree, inTree } from '../core/tree.ts'
-
-import { REACH, reachOf, type Target } from './target.ts'
-import { opened } from './vault.ts'
-
-const PRODUCTION = '--production'
-
-const METHOD = /^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*)*$/
-
-function isClass(fn: (...args: readonly unknown[]) => unknown): boolean {
-  return /^class[\s{]/.test(Function.prototype.toString.call(fn))
-}
-
-const ASKS: readonly { readonly key: string; readonly says: string }[] = [
-  {
-    key: 'args',
-    says: 'a JSON value — an array for positional arguments, anything else for one, blank for none',
-  },
-]
-
-const TAKES: readonly string[] = ASKS.map((one) => one.key)
-
-const ASKED: readonly string[] = ASKS.map((one) => `\`${one.key}\`: ${one.says}`)
-
-export async function ran(name: string): Promise<void> {
-  const say = (because: string): never => {
-    stderr.write(`${name}: ${because}\n`)
-    exit(1)
-  }
-
-  const tree = findTree()
-  let targets: readonly Target[] = []
-  try {
-    const taken = valuesIn(readFileSync(inTree(tree, 'targets.ts'))) as {
-      TARGETS?: readonly Target[]
-    }
-    targets = taken.TARGETS ?? []
-  } catch {
-    return say('`_threads/targets.ts` could not be read, so nothing says what this integration is.')
-  }
-
-  const mine = targets.find((one) => one.id === `${REACH.cli}${name}` || one.id === `${REACH.module}${name}`)
-  if (mine === undefined) {
-    return say(
-      `no target called \`${REACH.cli}${name}\` or \`${REACH.module}${name}\` is declared here, so this command should ` +
-        'not exist. Declare it with `thread create target`, or take its row out of `_threads/derivation.ts`.',
-    )
-  }
-
-  const does = mine.offers ?? []
-  const passed = argv.slice(2)
-  const sub = passed[0]
-
-  if (sub === undefined) {
-    stdout.write(
-      `${name}: ${mine.describes}\n\n${String(does.length)} command(s), read off \`${mine.uses ?? ''}\` when \`${mine.id}\` was declared:\n` +
-        `${does.join(', ') || '(none were readable — name them with `thread create target edit`)'}\n\n` +
-        `thread run ${name} <command> [anything else] — arguments and flags reach \`${mine.uses ?? ''}\` untouched.\n` +
-        `It takes ${String(ASKED.length)} answer(s): ${ASKED.join('; ')}.\n`,
-    )
-    exit(0)
-  }
-
-  if (!does.includes(sub)) {
-    return say(
-      `\`${sub}\` is not one of the ${String(does.length)} command(s) \`${mine.uses ?? ''}\` stated when \`${mine.id}\` ` +
-        `was declared. It declared: ${does.join(', ') || '(nothing)'}. If the tool has changed, read it again with ` +
-        `\`thread create target edit ${mine.id}\`.`,
-    )
-  }
-
-  if (reachOf(mine.id) === 'module') {
-    return run({ name, module: mine.uses ?? '', requires: mine.requires })
-  }
-
-  const went = spawnSync(mine.uses ?? '', passed, { cwd: tree.at, stdio: 'inherit' })
-  exit(went.status ?? 1)
-}
-
-export async function run(declared: {
-  readonly name: string
-  readonly module: string
-  readonly requires: readonly string[]
-}): Promise<void> {
-  const refuse = (because: string): never => {
-    stderr.write(`${declared.name}: ${because}\n`)
-    exit(1)
-  }
-
-  const method = wordsIn([])[0]
-  if (method === undefined) {
-    return refuse(
-      `takes the method to call, dot-separated for a namespaced one — e.g. \`thread run ${declared.name} customers.list\`.`,
-    )
-  }
-  if (!METHOD.test(method)) {
-    return refuse(`\`${method}\` is not a method path — one name, or names joined by dots, e.g. \`customers.list\``)
-  }
-
-  const piped = given()
-  unasked(piped, TAKES, `\`thread run ${declared.name} ${method}\``)
-  const { ask, shut } = asking(piped)
-  const typed = (
-    piped.length > 0
-      ? (answer(piped, TAKES[0] ?? 'args') ?? '')
-      : await ask('args', 'args, as JSON — an array for positional arguments, anything else for one (blank for none): ')
-  ).trim()
-  shut()
-
-  let args: unknown[] = []
-  if (typed !== '') {
-    let parsed: unknown
-    try {
-      parsed = JSON.parse(typed)
-    } catch (thrown) {
-      return refuse(`that is not JSON: ${thrown instanceof Error ? thrown.message : String(thrown)}. Nothing was called.`)
-    }
-    args = Array.isArray(parsed) ? parsed : [parsed]
-  }
-
-  const env: Env = argv.includes(PRODUCTION) ? 'production' : 'sandbox'
-
-  const opening = opened(findTree().at, declared.requires, env)
-  let resolved: Readonly<Record<string, string>>
-  try {
-    resolved = await opening(declared.requires)
-  } catch (thrown) {
-    return refuse(thrown instanceof Error ? thrown.message : String(thrown))
-  }
-  const credentials = declared.requires.map((one) => resolved[one] ?? '')
-
-  let mod: Record<string, unknown>
-  try {
-    mod = (await import(declared.module)) as Record<string, unknown>
-  } catch (thrown) {
-    return refuse(
-      `\`${declared.module}\` could not be imported: ${thrown instanceof Error ? thrown.message : String(thrown)}. It was ` +
-        `installed when this was declared — if it is gone, \`npm install ${declared.module}\` puts it back.`,
-    )
-  }
-
-  const entry: unknown = mod.default ?? mod
-
-  const asFunction = entry as (...a: readonly unknown[]) => unknown
-  const asConstructor = entry as new (...a: readonly unknown[]) => unknown
-
-const REACHES = new Set(['constructor', '__proto__', 'prototype'])
-
-  const client: unknown =
-    typeof entry !== 'function' ? entry : isClass(asFunction) ? Reflect.construct(asConstructor, credentials) : asFunction(...credentials)
-
-  let owner: unknown = client
-  let target: unknown = client
-  for (const segment of method.split('.')) {
-    if (REACHES.has(segment)) {
-      return refuse(
-        `\`${segment}\` is not an operation of \`${declared.module}\` — it is a step every JavaScript value has, and ` +
-          'walking to it leaves what was installed. What may run here is what the module exports, and a person fixed that ' +
-          'set when they declared it.',
-      )
-    }
-    owner = target
-    target = (target as Record<string, unknown> | null | undefined)?.[segment]
-  }
-  if (typeof target !== 'function') {
-    return refuse(`\`${method}\` on \`${declared.module}\` is ${target === undefined ? 'nothing' : `a ${typeof target}`}, not a method that can be called`)
-  }
-
-  let result: unknown
-  try {
-    result = await (target as (...a: unknown[]) => unknown).apply(owner, args)
-  } catch (thrown) {
-    return refuse(`\`${method}\` on \`${declared.module}\` threw: ${thrown instanceof Error ? thrown.message : String(thrown)}`)
-  }
-
-  stdout.write(`${declared.name}: ${method} (${env})\n`)
-  try {
-    stdout.write(`${JSON.stringify(result, null, 2)}\n`)
-  } catch {
-    stdout.write(`${String(result)}\n`)
-  }
-  exit(0)
-}

package/dist/integrity/slopnators/sl_unkept_rows.js

@@ -1,104 +0,0 @@
-import { existsSync, readdirSync, readFileSync } from "../../core/files.js";
-import { resolve } from 'node:path';
-const STORES = 'src/stores';
-/* What hands an operation its seams, seeded once and then the app's own. */
-const SEAMS = 'src/seams.ts';
-/* What the declarations settle, which the seams file is expected to hand on. */
-const DECLARED = 'DECLARED';
-/*
- * WHAT THIS READS, AND WHY IT READS THAT RATHER THAN THE TARGETS SHEET.
- *
- * A target that keeps entities derives a store of its own, written by `thread schema` into
- * `src/stores/<target>.ts`. So one of those files existing IS the fact that this app declares
- * somewhere to keep rows — already resolved, by the command that resolved it, with no second reading
- * of what a reach can hold and no chance of the two disagreeing about it.
- *
- * Where rows go is settled in `src/_generated/seams.ts`, which `thread capabilities` writes from those
- * stores and refuses when it drifts. The one place it can still go wrong is `src/seams.ts`, which is
- * the app's own: an app that stops handing on what was settled there hands its operations a store
- * that keeps nothing, while the tables are written, the migrations are written, and the gate is green.
- */
-function held(root, at) {
-    const path = resolve(root, at);
-    try {
-        return existsSync(path) ? readFileSync(path, 'utf8') : '';
-    }
-    catch {
-        return '';
-    }
-}
-function derived(root) {
-    const at = resolve(root, STORES);
-    try {
-        return existsSync(at) ? readdirSync(at).filter((one) => one.endsWith('.ts')) : [];
-    }
-    catch {
-        return [];
-    }
-}
-export const slopnator = {
-    checks: (root) => {
-        const stores = derived(root);
-        if (stores.length === 0)
-            return [];
-        /*
-         * AN APP WITH NOTHING THAT HANDS A STORE TO AN OPERATION IS NOT KEEPING ROWS THROUGH ONE, SO
-         * THERE IS NOTHING TO REFUSE.
-         *
-         * The seams file is seeded by `thread capabilities`, which ships in the operations package — so
-         * an app that attached data and integrity and nothing else has no seams and no command that
-         * seeds one. Its absence means rows go nowhere yet, which is a state to pass rather than refuse:
-         * nothing is being lost, because nothing is being kept.
-         */
-        const where = held(root, SEAMS);
-        if (where === '')
-            return [];
-        if (where.includes(DECLARED))
-            return [];
-        return [
-            `${STORES} holds ${stores.join(', ')} and ${SEAMS} no longer hands on ${DECLARED}, so every row this app keeps goes ` +
-                'somewhere that is gone the moment it stops. The tables are written, the migrations are written, the gate is ' +
-                `green, and the database is never opened. Spread ${DECLARED} back into SEAMS, or name its store there`,
-        ];
-    },
-    proves: {
-        wrong: [
-            {
-                files: [
-                    { at: 'src/stores/pl_probe.ts', source: 'export const store = {}\n' },
-                    {
-                        at: 'src/seams.ts',
-                        source: "import { inMemorySeams } from '../../operations/memory.ts'\n\nexport const SEAMS = inMemorySeams().seams\n",
-                    },
-                ],
-                at: 'src/seams.ts',
-            },
-        ],
-        right: [
-            {
-                files: [
-                    { at: 'src/stores/pl_probe.ts', source: 'export const store = {}\n' },
-                    {
-                        at: 'src/seams.ts',
-                        source: "import { DECLARED } from './_generated/seams.ts'\n\nexport const SEAMS = { ...DECLARED }\n",
-                    },
-                ],
-                at: 'src/seams.ts',
-            },
-            /* An app that derived a store and has nothing handing one to an operation — data attached, operations not. */
-            {
-                files: [{ at: 'src/stores/pl_probe.ts', source: 'export const store = {}\n' }],
-                at: 'src/seams.ts',
-            },
-            {
-                files: [
-                    {
-                        at: 'src/seams.ts',
-                        source: "import { inMemorySeams } from '../../operations/memory.ts'\n\nexport const SEAMS = inMemorySeams().seams\n",
-                    },
-                ],
-                at: 'src/seams.ts',
-            },
-        ],
-    },
-};

package/dist/integrity/slopnators/sl_unkept_rows.ts

@@ -1,111 +0,0 @@
-import { existsSync, readdirSync, readFileSync } from '../../core/files.ts'
-import { resolve } from 'node:path'
-
-import type { Slopnator } from '../slopnator.ts'
-
-const STORES = 'src/stores'
-
-/* What hands an operation its seams, seeded once and then the app's own. */
-const SEAMS = 'src/seams.ts'
-
-/* What the declarations settle, which the seams file is expected to hand on. */
-const DECLARED = 'DECLARED'
-
-/*
- * WHAT THIS READS, AND WHY IT READS THAT RATHER THAN THE TARGETS SHEET.
- *
- * A target that keeps entities derives a store of its own, written by `thread schema` into
- * `src/stores/<target>.ts`. So one of those files existing IS the fact that this app declares
- * somewhere to keep rows — already resolved, by the command that resolved it, with no second reading
- * of what a reach can hold and no chance of the two disagreeing about it.
- *
- * Where rows go is settled in `src/_generated/seams.ts`, which `thread capabilities` writes from those
- * stores and refuses when it drifts. The one place it can still go wrong is `src/seams.ts`, which is
- * the app's own: an app that stops handing on what was settled there hands its operations a store
- * that keeps nothing, while the tables are written, the migrations are written, and the gate is green.
- */
-function held(root: string, at: string): string {
-  const path = resolve(root, at)
-  try {
-    return existsSync(path) ? readFileSync(path, 'utf8') : ''
-  } catch {
-    return ''
-  }
-}
-
-function derived(root: string): readonly string[] {
-  const at = resolve(root, STORES)
-  try {
-    return existsSync(at) ? readdirSync(at).filter((one) => one.endsWith('.ts')) : []
-  } catch {
-    return []
-  }
-}
-
-export const slopnator: Slopnator = {
-  checks: (root) => {
-    const stores = derived(root)
-    if (stores.length === 0) return []
-
-    /*
-     * AN APP WITH NOTHING THAT HANDS A STORE TO AN OPERATION IS NOT KEEPING ROWS THROUGH ONE, SO
-     * THERE IS NOTHING TO REFUSE.
-     *
-     * The seams file is seeded by `thread capabilities`, which ships in the operations package — so
-     * an app that attached data and integrity and nothing else has no seams and no command that
-     * seeds one. Its absence means rows go nowhere yet, which is a state to pass rather than refuse:
-     * nothing is being lost, because nothing is being kept.
-     */
-    const where = held(root, SEAMS)
-    if (where === '') return []
-
-    if (where.includes(DECLARED)) return []
-
-    return [
-      `${STORES} holds ${stores.join(', ')} and ${SEAMS} no longer hands on ${DECLARED}, so every row this app keeps goes ` +
-        'somewhere that is gone the moment it stops. The tables are written, the migrations are written, the gate is ' +
-        `green, and the database is never opened. Spread ${DECLARED} back into SEAMS, or name its store there`,
-    ]
-  },
-  proves: {
-    wrong: [
-      {
-        files: [
-          { at: 'src/stores/pl_probe.ts', source: 'export const store = {}\n' },
-          {
-            at: 'src/seams.ts',
-            source: "import { inMemorySeams } from '../../operations/memory.ts'\n\nexport const SEAMS = inMemorySeams().seams\n",
-          },
-        ],
-        at: 'src/seams.ts',
-      },
-    ],
-    right: [
-      {
-        files: [
-          { at: 'src/stores/pl_probe.ts', source: 'export const store = {}\n' },
-          {
-            at: 'src/seams.ts',
-            source: "import { DECLARED } from './_generated/seams.ts'\n\nexport const SEAMS = { ...DECLARED }\n",
-          },
-        ],
-        at: 'src/seams.ts',
-      },
-
-      /* An app that derived a store and has nothing handing one to an operation — data attached, operations not. */
-      {
-        files: [{ at: 'src/stores/pl_probe.ts', source: 'export const store = {}\n' }],
-        at: 'src/seams.ts',
-      },
-      {
-        files: [
-          {
-            at: 'src/seams.ts',
-            source: "import { inMemorySeams } from '../../operations/memory.ts'\n\nexport const SEAMS = inMemorySeams().seams\n",
-          },
-        ],
-        at: 'src/seams.ts',
-      },
-    ],
-  },
-}

package/dist/integrity/slopnators/sl_unseamed_reach.js

@@ -1,73 +0,0 @@
-import { isBuiltin } from 'node:module';
-import { parser } from 'typescript-eslint';
-const CODE = /\.(?:ts|tsx|mts|cts|js|jsx|mjs|cjs)$/;
-const MENTIONS = /\bimport\b|\brequire\s*\(/;
-function reached(node, seen, found) {
-    if (typeof node !== 'object' || node === null)
-        return;
-    if (seen.has(node))
-        return;
-    seen.add(node);
-    if (Array.isArray(node)) {
-        for (const each of node)
-            reached(each, seen, found);
-        return;
-    }
-    const one = node;
-    const type = one['type'];
-    if (type === 'ImportDeclaration' || type === 'ImportExpression' || type === 'ExportNamedDeclaration' || type === 'ExportAllDeclaration') {
-        const source = one['source'];
-        if (typeof source?.value === 'string')
-            found(source.value);
-    }
-    if (type === 'CallExpression') {
-        const callee = one['callee'];
-        if (callee?.type === 'Identifier' && callee.name === 'require') {
-            const first = one['arguments']?.[0];
-            if (typeof first?.value === 'string')
-                found(first.value);
-        }
-    }
-    for (const held of Object.values(one))
-        reached(held, seen, found);
-}
-export const slopnator = {
-    holds: (_node, at) => {
-        if (!CODE.test(at.filename))
-            return false;
-        const text = String(at.text);
-        if (!MENTIONS.test(text))
-            return false;
-        let ast;
-        try {
-            ast = parser.parseForESLint(text, {
-                range: true,
-                ecmaVersion: 'latest',
-                sourceType: 'module',
-                ecmaFeatures: { jsx: true },
-            }).ast;
-        }
-        catch {
-            return false;
-        }
-        const taken = new Set();
-        reached(ast, new WeakSet(), (one) => {
-            if (isBuiltin(one))
-                taken.add(one);
-        });
-        if (taken.size === 0)
-            return false;
-        return `this reaches ${[...taken].sort().join(', ')} straight from the runtime, and a node is handed everything it may touch`;
-    },
-    proves: {
-        wrong: [
-            "import { readFileSync } from 'node:fs'\nexport const node = readFileSync\n",
-            "const { spawn } = require('child_process')\nexport const node = spawn\n",
-            "export const node = async () => await import('node:net')\n",
-        ],
-        right: [
-            "import { nd_read } from '../../operations/nodes.ts'\nexport const node = nd_read(async (hands) => await hands.store.get('a', 'b'))\n",
-            "import type { In } from './input.ts'\nexport const node = null as unknown as In\n",
-        ],
-    },
-};

package/dist/integrity/slopnators/sl_unseamed_reach.ts

@@ -1,79 +0,0 @@
-import { isBuiltin } from 'node:module'
-
-import { parser } from 'typescript-eslint'
-
-import type { Slopnator } from '../slopnator.ts'
-
-const CODE = /\.(?:ts|tsx|mts|cts|js|jsx|mjs|cjs)$/
-
-const MENTIONS = /\bimport\b|\brequire\s*\(/
-
-function reached(node: unknown, seen: WeakSet<object>, found: (one: string) => void): void {
-  if (typeof node !== 'object' || node === null) return
-  if (seen.has(node)) return
-  seen.add(node)
-
-  if (Array.isArray(node)) {
-    for (const each of node) reached(each, seen, found)
-    return
-  }
-
-  const one = node as Record<string, unknown>
-  const type = one['type']
-
-  if (type === 'ImportDeclaration' || type === 'ImportExpression' || type === 'ExportNamedDeclaration' || type === 'ExportAllDeclaration') {
-    const source = one['source'] as { readonly value?: unknown } | null | undefined
-    if (typeof source?.value === 'string') found(source.value)
-  }
-
-  if (type === 'CallExpression') {
-    const callee = one['callee'] as { readonly type?: unknown; readonly name?: unknown } | null | undefined
-    if (callee?.type === 'Identifier' && callee.name === 'require') {
-      const first = (one['arguments'] as readonly { readonly value?: unknown }[] | undefined)?.[0]
-      if (typeof first?.value === 'string') found(first.value)
-    }
-  }
-
-  for (const held of Object.values(one)) reached(held, seen, found)
-}
-
-export const slopnator: Slopnator = {
-  holds: (_node, at) => {
-    if (!CODE.test(at.filename)) return false
-
-    const text = String(at.text)
-    if (!MENTIONS.test(text)) return false
-
-    let ast: unknown
-    try {
-      ast = (parser.parseForESLint as (text: string, options: unknown) => { readonly ast: unknown })(text, {
-        range: true,
-        ecmaVersion: 'latest',
-        sourceType: 'module',
-        ecmaFeatures: { jsx: true },
-      }).ast
-    } catch {
-      return false
-    }
-
-    const taken = new Set<string>()
-    reached(ast, new WeakSet<object>(), (one) => {
-      if (isBuiltin(one)) taken.add(one)
-    })
-
-    if (taken.size === 0) return false
-
-    return `this reaches ${[...taken].sort().join(', ')} straight from the runtime, and a node is handed everything it may touch`
-  },
-  proves: {
-    wrong: [
-      "import { readFileSync } from 'node:fs'\nexport const node = readFileSync\n",
-      "const { spawn } = require('child_process')\nexport const node = spawn\n",
-      "export const node = async () => await import('node:net')\n",
-    ],
-    right: [
-      "import { nd_read } from '../../operations/nodes.ts'\nexport const node = nd_read(async (hands) => await hands.store.get('a', 'b'))\n",
-      "import type { In } from './input.ts'\nexport const node = null as unknown as In\n",
-    ],
-  },
-}

package/dist/operations/cost.d.ts

@@ -1,14 +0,0 @@
-export interface CostAmount {
-    readonly usdMicroCents: number;
-    readonly chargedMicroCents: number;
-    readonly currency: string;
-    readonly meter: string;
-}
-export declare class InvalidCostError extends Error {
-    constructor(message: string);
-}
-export declare function assertValidCost(cost: CostAmount): void;
-export declare const MICRO_CENTS_PER_CENT = 1000000;
-export declare const MICRO_CENTS_PER_UNIT = 100000000;
-export declare function toMicroCents(amount: number): number;
-export declare function fromMicroCents(microCents: number): number;

package/dist/operations/cost.js

@@ -1,37 +0,0 @@
-export class InvalidCostError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = 'InvalidCostError';
-    }
-}
-function assertIntegerMicroCents(value, field) {
-    if (!Number.isFinite(value) || !Number.isInteger(value)) {
-        throw new InvalidCostError(`${field} must be an integer number of micro-cents, received ${value}. ` +
-            'Convert before recording — never round.');
-    }
-    if (value < 0)
-        throw new InvalidCostError(`${field} must not be negative, received ${value}`);
-}
-export function assertValidCost(cost) {
-    assertIntegerMicroCents(cost.usdMicroCents, 'usdMicroCents');
-    assertIntegerMicroCents(cost.chargedMicroCents, 'chargedMicroCents');
-    if (typeof cost.currency !== 'string' || cost.currency.trim() === '') {
-        throw new InvalidCostError('cost.currency is required and has no default — resolve it from real data (DATA.md §8)');
-    }
-    if (!/^[A-Z]{3}$/.test(cost.currency)) {
-        throw new InvalidCostError(`cost.currency must be an ISO-4217 code, received "${cost.currency}"`);
-    }
-    if (typeof cost.meter !== 'string' || cost.meter.trim() === '') {
-        throw new InvalidCostError('cost.meter is required — a cost with no meter cannot be quota-checked');
-    }
-}
-export const MICRO_CENTS_PER_CENT = 1_000_000;
-export const MICRO_CENTS_PER_UNIT = 100_000_000;
-export function toMicroCents(amount) {
-    if (!Number.isFinite(amount))
-        throw new InvalidCostError(`cannot convert ${amount} to micro-cents`);
-    return Math.round(amount * MICRO_CENTS_PER_UNIT);
-}
-export function fromMicroCents(microCents) {
-    return microCents / MICRO_CENTS_PER_UNIT;
-}

package/dist/operations/cost.ts

@@ -1,58 +0,0 @@
-export interface CostAmount {
-
-  readonly usdMicroCents: number
-
-  readonly chargedMicroCents: number
-
-  readonly currency: string
-
-  readonly meter: string
-}
-
-export class InvalidCostError extends Error {
-  constructor(message: string) {
-    super(message)
-    this.name = 'InvalidCostError'
-  }
-}
-
-function assertIntegerMicroCents(value: number, field: string): void {
-  if (!Number.isFinite(value) || !Number.isInteger(value)) {
-
-    throw new InvalidCostError(
-      `${field} must be an integer number of micro-cents, received ${value}. ` +
-        'Convert before recording — never round.',
-    )
-  }
-  if (value < 0) throw new InvalidCostError(`${field} must not be negative, received ${value}`)
-}
-
-export function assertValidCost(cost: CostAmount): void {
-  assertIntegerMicroCents(cost.usdMicroCents, 'usdMicroCents')
-  assertIntegerMicroCents(cost.chargedMicroCents, 'chargedMicroCents')
-
-  if (typeof cost.currency !== 'string' || cost.currency.trim() === '') {
-    throw new InvalidCostError(
-      'cost.currency is required and has no default — resolve it from real data (DATA.md §8)',
-    )
-  }
-  if (!/^[A-Z]{3}$/.test(cost.currency)) {
-    throw new InvalidCostError(`cost.currency must be an ISO-4217 code, received "${cost.currency}"`)
-  }
-  if (typeof cost.meter !== 'string' || cost.meter.trim() === '') {
-    throw new InvalidCostError('cost.meter is required — a cost with no meter cannot be quota-checked')
-  }
-}
-
-export const MICRO_CENTS_PER_CENT = 1_000_000
-
-export const MICRO_CENTS_PER_UNIT = 100_000_000
-
-export function toMicroCents(amount: number): number {
-  if (!Number.isFinite(amount)) throw new InvalidCostError(`cannot convert ${amount} to micro-cents`)
-  return Math.round(amount * MICRO_CENTS_PER_UNIT)
-}
-
-export function fromMicroCents(microCents: number): number {
-  return microCents / MICRO_CENTS_PER_UNIT
-}