@lapxo/topos 0.1.0

package/dist/authority/admit.d.ts

@@ -0,0 +1,2 @@
+/** Segment boundary, not string prefix — `acme/user` must not bind `acme/userdata`. */
+export declare function under(prefix: string, scope: string): boolean;

package/dist/authority/admit.js

@@ -0,0 +1,5 @@
+import { region, within } from '@lapxo/obligations/field';
+/** Segment boundary, not string prefix — `acme/user` must not bind `acme/userdata`. */
+export function under(prefix, scope) {
+    return prefix !== '' && within(region(scope, './'), region(prefix, './'));
+}

package/dist/authority/index.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Owner subpath `@lapxo/topos/authority` — prefix binds and key class.
+ */
+export { keyClassFor } from './motion.ts';

package/dist/authority/index.js

@@ -0,0 +1,4 @@
+/**
+ * Owner subpath `@lapxo/topos/authority` — prefix binds and key class.
+ */
+export { keyClassFor } from "./motion.js";

package/dist/authority/motion.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Authority is the direction of the move, not the kind of actor.
+ * Narrow is attest. Widen is authorize.
+ *
+ * Seven state actions. `foreign` is a location (out of domain), not a verb.
+ * `derives` is a reference relation, not a movement.
+ */
+type Motion = 'narrow' | 'widen';
+export type KeyClass = 'attest' | 'authorize';
+export declare function keyClassFor(motion: Motion): KeyClass;
+export {};

package/dist/authority/motion.js

@@ -0,0 +1,3 @@
+export function keyClassFor(motion) {
+    return motion === 'widen' ? 'authorize' : 'attest';
+}

package/dist/capsule/asked.d.ts

@@ -0,0 +1,28 @@
+export type Handed = Readonly<Record<string, string>>;
+interface Held {
+    readonly lines: readonly Handed[];
+    readonly receipts: readonly Handed[];
+}
+/**
+ * What a render capsule is asked: one region of one place, at a resolution, the reads it was handed by and the lines
+ * they gave, and for each region of the place it reads, that region's lines and its receipts; each handed as its
+ * fields, never as its text.
+ */
+export interface Asked {
+    readonly region: string;
+    readonly at: number;
+    readonly shape: string;
+    readonly name: string;
+    readonly reads: readonly string[];
+    readonly lines: readonly Handed[];
+    readonly regions: Readonly<Record<string, Held>>;
+}
+export declare const of: (line: Handed | undefined, field: string) => string;
+export declare const found: (asked: Asked, scope: string) => Handed | undefined;
+export declare const value: (asked: Asked, scope: string) => string | undefined;
+export declare const listed: (asked: Asked, scope: string) => readonly string[];
+export declare const lang: (asked: Asked) => string;
+export declare const receipts: (asked: Asked, region: string) => readonly Handed[];
+export declare const placeOf: (line: Handed) => string;
+export declare const regionLines: (asked: Asked, region: string) => readonly Handed[];
+export {};

package/dist/capsule/asked.js

@@ -0,0 +1,9 @@
+import { alphabet } from "../wire/grammar.js";
+export const of = (line, field) => line?.[field] ?? '';
+export const found = (asked, scope) => asked.lines.find((line) => of(line, 'scope') === scope);
+export const value = (asked, scope) => (found(asked, scope) === undefined ? undefined : of(found(asked, scope), 'value'));
+export const listed = (asked, scope) => alphabet(value(asked, scope) ?? '').members;
+export const lang = (asked) => value(asked, 'lang') ?? '';
+export const receipts = (asked, region) => asked.regions[region]?.receipts ?? [];
+export const placeOf = (line) => of(line, 'at').replace(/^[^:]*:/, '');
+export const regionLines = (asked, region) => asked.regions[region]?.lines ?? [];

package/dist/capsule/declaration.d.ts

@@ -0,0 +1,26 @@
+import type { Handed } from './asked.ts';
+export interface Declaration {
+    readonly domain: string;
+    readonly runtime?: string;
+    readonly holds?: string;
+    readonly pins: Readonly<Record<string, string>>;
+    readonly renders: readonly string[];
+    readonly reads: readonly string[];
+    readonly regions: Readonly<Record<string, readonly string[]>>;
+    readonly writes: Readonly<Record<string, string>>;
+    readonly effects: readonly string[];
+}
+/**
+ * What a capsule's own lock says of it: the domain it serves, the runtime the host starts it with, where its world holds
+ * its values, the release it pins of each package it bundles, and one line per region — what the region reads, and its
+ * role: a render writes a page, a receipt is a reader's claims. The paths a place's regions cover are lines of another
+ * measure and no region of the capsule. A lock of the older shape names its regions in one list and their reads one line
+ * each; one that reads as one is read as one. A region no line names reads nothing and is refused.
+ */
+export declare function declarationOf(lines: readonly string[]): Declaration;
+export declare const readsOf: (declaration: Declaration, region: string) => readonly string[] | undefined;
+/**
+ * The lines a capsule sees, handed by the contract: the standing lines of the place that lie in a region its own lock
+ * reads, parsed by the wire. Nothing else of the lock reaches it, and no file does.
+ */
+export declare function handed(reads: readonly string[], lines: readonly string[]): readonly Handed[];

package/dist/capsule/declaration.js

@@ -0,0 +1,45 @@
+import { matches } from "../wire/classes.js";
+import { alphabet } from "../wire/grammar.js";
+import { parse } from "../wire/line.js";
+const standing = (lines) => lines.flatMap((line) => {
+    const got = parse(line);
+    return got.kind === 'fact' && got.value.fields['value'] !== 'withdraw' ? [got.value.fields] : [];
+});
+/**
+ * What a capsule's own lock says of it: the domain it serves, the runtime the host starts it with, where its world holds
+ * its values, the release it pins of each package it bundles, and one line per region — what the region reads, and its
+ * role: a render writes a page, a receipt is a reader's claims. The paths a place's regions cover are lines of another
+ * measure and no region of the capsule. A lock of the older shape names its regions in one list and their reads one line
+ * each; one that reads as one is read as one. A region no line names reads nothing and is refused.
+ */
+export function declarationOf(lines) {
+    const held = standing(lines);
+    const said = (scope) => held.filter((fields) => fields['scope'] === scope)
+        .flatMap((fields) => alphabet(fields['value'] ?? '').members);
+    const own = held.filter((fields) => (fields['scope'] ?? '').startsWith('region/') && fields['measure'] === 'reads');
+    const named = (fields, prefix) => (fields['scope'] ?? '').slice(prefix.length);
+    const reading = (scope) => own.filter((fields) => fields['scope'] === scope).flatMap((fields) => alphabet(fields['value'] ?? '').members);
+    const regions = Object.fromEntries(own.length ? own.map((fields) => [named(fields, 'region/'), reading(fields['scope'] ?? '')])
+        : held.filter((fields) => (fields['scope'] ?? '').startsWith('capsule/reads/')).map((fields) => [named(fields, 'capsule/reads/'), said(fields['scope'] ?? '')]));
+    const [runtime, holds] = [said('capsule/runtime')[0], said('capsule/holds')[0]];
+    return {
+        domain: said('capsule/domain')[0] ?? '',
+        ...(runtime === undefined ? {} : { runtime }),
+        ...(holds === undefined ? {} : { holds }),
+        pins: Object.fromEntries(held.filter((fields) => (fields['scope'] ?? '').startsWith('capsule/') && fields['measure'] === 'digest')
+            .map((fields) => [named(fields, 'capsule/'), fields['value'] ?? ''])),
+        renders: own.length ? own.filter((fields) => fields['role'] === 'render').map((fields) => named(fields, 'region/')) : said('capsule/regions'),
+        reads: [...new Set([...said('capsule/reads'), ...Object.values(regions).flat()])],
+        regions,
+        writes: Object.fromEntries(own.map((fields) => [named(fields, 'region/'), fields['role'] ?? ''])),
+        effects: said('capsule/effects'),
+    };
+}
+export const readsOf = (declaration, region) => (Object.keys(declaration.regions).length ? declaration.regions[region] : declaration.reads);
+/**
+ * The lines a capsule sees, handed by the contract: the standing lines of the place that lie in a region its own lock
+ * reads, parsed by the wire. Nothing else of the lock reaches it, and no file does.
+ */
+export function handed(reads, lines) {
+    return standing(lines).filter((fields) => reads.some((region) => matches(region, fields['scope'] ?? '')));
+}

package/dist/capsule/index.d.ts

@@ -0,0 +1,3 @@
+export * from './asked.ts';
+export * from './declaration.ts';
+export * from './shell.ts';

package/dist/capsule/index.js

@@ -0,0 +1,3 @@
+export * from "./asked.js";
+export * from "./declaration.js";
+export * from "./shell.js";

package/dist/capsule/shell.d.ts

@@ -0,0 +1,51 @@
+import type { Asked } from './asked.ts';
+type Region = (asked: Asked) => readonly string[];
+/**
+ * The shell a capsule's rendered index hands its regions to: a region is answered only when it was handed every read
+ * its own line declares, and one handed less is refused — the no every render capsule carries without writing it.
+ */
+export declare function shell(regions: Readonly<Record<string, {
+    readonly reads: readonly string[];
+    readonly region: Region;
+}>>): Region;
+type Handed = readonly {
+    readonly place: string;
+    readonly text: string;
+}[];
+type Observe = (bytes: Uint8Array, place: string, files: Handed) => readonly unknown[];
+type Run = (place: string, self: string, held: readonly (readonly [string, string])[]) => readonly unknown[];
+type Reading = {
+    readonly reads: readonly string[];
+    readonly observe?: Observe;
+    readonly run?: Run;
+};
+/**
+ * The shell a reader capsule's rendered index hands its readers to: each is asked as the region its own line names, and
+ * reads only what that line declares it reads — a region fits a read when some tail of its steps matches the read's glob,
+ * and what follows its `@` is the resolution it is handed at. A region no line names is refused, and so is a file of another shape.
+ */
+export declare function readers(regions: Readonly<Record<string, Reading>>): {
+    readonly observe: (bytes: Uint8Array, place: string, region?: string, files?: Handed) => readonly unknown[];
+    readonly run: (place: string, self: string, held: readonly (readonly [string, string])[], region?: string) => readonly unknown[];
+};
+type Measured = {
+    readonly scope: string;
+    readonly measure: string;
+    readonly role: 'reads';
+    readonly bound: {
+        readonly kind: 'interval';
+        readonly lo: number;
+        readonly hi: number;
+    };
+};
+export declare const counted: (asked: Asked, what: string, n: number, measure: string) => readonly Measured[];
+/**
+ * The shell a capsule's rendered index hands its receipt regions to: a region answers claims, and only when it was
+ * handed every read its own line declares; one handed less is refused, as a render is. A reading it answers is `counted`:
+ * a count, named by the region that read it and by what it counted.
+ */
+export declare function receiptShell(regions: Readonly<Record<string, {
+    readonly reads: readonly string[];
+    readonly region: (asked: Asked) => readonly unknown[];
+}>>): (asked: Asked) => readonly unknown[];
+export {};

package/dist/capsule/shell.js

@@ -0,0 +1,64 @@
+import { matches } from "../wire/classes.js";
+import { atResolution, steps } from "../wire/grammar.js";
+/**
+ * The shell a capsule's rendered index hands its regions to: a region is answered only when it was handed every read
+ * its own line declares, and one handed less is refused — the no every render capsule carries without writing it.
+ */
+export function shell(regions) {
+    return (asked) => {
+        const one = regions[asked.region];
+        if (one === undefined)
+            throw new Error(`REFUSE·region ${asked.region}: no line of this capsule renders it`);
+        const short = one.reads.filter((read) => !asked.reads.includes(read));
+        if (short.length)
+            throw new Error(`REFUSE·region ${asked.region}: handed less than it declares, without ${short.join(' · ')}`);
+        return one.region(asked);
+    };
+}
+const fits = (read, place) => {
+    const glob = atResolution(read).name;
+    const [bare, tail] = place.endsWith('/') ? [place.slice(0, -1), '/'] : [place, ''];
+    const held = steps(bare);
+    return held.some((_, i) => matches(glob, `${steps(held.slice(i))}${tail}`));
+};
+/**
+ * The shell a reader capsule's rendered index hands its readers to: each is asked as the region its own line names, and
+ * reads only what that line declares it reads — a region fits a read when some tail of its steps matches the read's glob,
+ * and what follows its `@` is the resolution it is handed at. A region no line names is refused, and so is a file of another shape.
+ */
+export function readers(regions) {
+    const one = (region, places) => {
+        const held = region === undefined ? undefined : regions[region];
+        if (held === undefined)
+            throw new Error(`REFUSE·region ${region ?? ''}: no line of this capsule reads with it`);
+        const outside = places.filter((place) => !held.reads.some((read) => fits(read, place)));
+        if (outside.length)
+            throw new Error(`REFUSE·region ${region}: ${outside.join(' · ')} is none of ${held.reads.join(' · ')}`);
+        return held;
+    };
+    return {
+        observe: (bytes, place, region, files = []) => ((held) => (held.observe ? held.observe(bytes, place, files) : []))(one(region, files.length ? files.map((file) => file.place) : [place])),
+        run: (place, self, held, region) => ((reading) => {
+            if (!reading.run)
+                throw new Error(`REFUSE·region ${region ?? ''}: it reads the files it is handed, and none was handed`);
+            return reading.run(place, self, held);
+        })(one(region, [place])),
+    };
+}
+export const counted = (asked, what, n, measure) => [{ scope: `${asked.region}/${what}`, measure, role: 'reads', bound: { kind: 'interval', lo: n, hi: n } }];
+/**
+ * The shell a capsule's rendered index hands its receipt regions to: a region answers claims, and only when it was
+ * handed every read its own line declares; one handed less is refused, as a render is. A reading it answers is `counted`:
+ * a count, named by the region that read it and by what it counted.
+ */
+export function receiptShell(regions) {
+    return (asked) => {
+        const one = regions[asked.region];
+        if (one === undefined)
+            throw new Error(`REFUSE·region ${asked.region}: no line of this capsule answers it`);
+        const short = one.reads.filter((read) => !asked.reads.includes(read));
+        if (short.length)
+            throw new Error(`REFUSE·region ${asked.region}: handed less than it declares, without ${short.join(' · ')}`);
+        return one.region(asked);
+    };
+}

package/dist/classes/scale.d.ts

@@ -0,0 +1,16 @@
+/**
+ * One scale constructor. The class name on the wire stays `forms`.
+ * Lattice and count are inert references — type-only algebra ports; no runtime import.
+ */
+export interface ScaleDescriptor {
+    readonly id: string;
+    readonly universe: string;
+    readonly order: string;
+    readonly generators?: readonly string[];
+    readonly lattice?: string;
+    readonly count?: string;
+    readonly sample: {
+        readonly yes: readonly unknown[];
+        readonly no: readonly unknown[];
+    };
+}

package/dist/classes/scale.js

@@ -0,0 +1 @@
+export {};

package/dist/contract/index.d.ts

@@ -0,0 +1,27 @@
+import type { Asked } from '../capsule/index.ts';
+import type { Request, Response } from '../wire/spec.ts';
+export type { Request, Response } from '../wire/spec.ts';
+type Answering = {
+    readonly observe?: (bytes: Uint8Array, place: string, region?: string, files?: readonly {
+        readonly place: string;
+        readonly text: string;
+    }[]) => readonly unknown[];
+    readonly run?: (place: string, self: string, held: readonly (readonly [string, string])[], region?: string) => readonly unknown[];
+    readonly render?: (asked: Asked) => readonly string[];
+    readonly receipt?: (asked: Asked) => readonly unknown[];
+};
+/**
+ * The one contract across processes, and the one serve: a module's one export answers each request, a reader's by
+ * observing the file it is handed or, handed none, running the place it names, as the region asked when it holds several, a capsule's
+ * by rendering a region, or by answering the claims of a receipt region, from the lines its own lock reads, parsed here and handed over. What throws is a refusal, what the module has no export for is an
+ * abstention, and a reader that can only observe is refused when no file is handed: it never reads an empty one. The host reads and writes, this never does.
+ */
+export declare function answer(module: Answering, request: Request, self: string): Response;
+/**
+ * Observation is the contract's, not a global's: a runner listens once, and a harness hands each sample it loaded through
+ * `observed`, which notes every field of a case a block reads by where the case came from; nobody listening, nothing is noted.
+ */
+export declare const listen: (note: ((at: string) => void) | undefined) => ((at: string) => void) | undefined;
+export declare const observed: <T extends Readonly<Record<string, unknown>>>(held: T, at: string) => T;
+export declare const respond: (module: Answering, input: string, self: string) => string;
+export declare function responsesOf(printed: string, asked: number): readonly Response[];

package/dist/contract/index.js

@@ -0,0 +1,63 @@
+/** It answers what a world answers — render, receipt, observe, run — what does a world owe? */
+import { handed } from "../capsule/index.js";
+import { PROTOCOL } from "../wire/line.js";
+/**
+ * The one contract across processes, and the one serve: a module's one export answers each request, a reader's by
+ * observing the file it is handed or, handed none, running the place it names, as the region asked when it holds several, a capsule's
+ * by rendering a region, or by answering the claims of a receipt region, from the lines its own lock reads, parsed here and handed over. What throws is a refusal, what the module has no export for is an
+ * abstention, and a reader that can only observe is refused when no file is handed: it never reads an empty one. The host reads and writes, this never does.
+ */
+export function answer(module, request, self) {
+    try {
+        const asked = () => {
+            const reads = request.reads ?? [];
+            const regions = Object.fromEntries(Object.entries(request.regions ?? {}).filter(([name]) => reads.includes(`region/${name}`))
+                .map(([name, held]) => [name, { lines: handed(['**'], held.lines), receipts: handed(['**'], held.receipts) }]));
+            return { region: request.region ?? '', at: request.at ?? 3, shape: request.shape ?? '', name: request.name ?? '', reads, lines: handed(reads, request.lines ?? []), regions };
+        };
+        if (request.verb === 'render' && module.render)
+            return { protocol: PROTOCOL, kind: 'fact', lines: module.render(asked()) };
+        if (request.verb === 'read' && module.receipt && request.reads !== undefined)
+            return { protocol: PROTOCOL, kind: 'fact', claims: module.receipt(asked()) };
+        const file = request.files[0];
+        if (request.verb === 'read' && module.observe && file !== undefined) {
+            return { protocol: PROTOCOL, kind: 'fact', claims: module.observe(new TextEncoder().encode(file.text), request.rootScope, request.region, request.files) };
+        }
+        if (request.verb === 'read' && module.run)
+            return { protocol: PROTOCOL, kind: 'fact', claims: module.run(request.rootScope, self, request.held ?? [], request.region) };
+        if (request.verb === 'read' && module.observe)
+            return { protocol: PROTOCOL, kind: 'refuse', why: 'no file was handed to observe' };
+        return { protocol: PROTOCOL, kind: 'abstain', why: `no export answers ${request.verb}` };
+    }
+    catch (thrown) {
+        return { protocol: PROTOCOL, kind: 'refuse', why: String(thrown) };
+    }
+}
+/**
+ * Observation is the contract's, not a global's: a runner listens once, and a harness hands each sample it loaded through
+ * `observed`, which notes every field of a case a block reads by where the case came from; nobody listening, nothing is noted.
+ */
+export const listen = (note) => {
+    const was = globalThis.__boundRead;
+    globalThis.__boundRead = note;
+    return was;
+};
+export const observed = (held, at) => {
+    const note = globalThis.__boundRead;
+    if (note === undefined || !Array.isArray(held['cases']))
+        return held;
+    const cases = held['cases'].map((one, i) => new Proxy(one, {
+        get: (target, field, receiver) => {
+            if (typeof field === 'string')
+                note(`${at}#${i}:${field}`);
+            return Reflect.get(target, field, receiver);
+        },
+    }));
+    return { ...held, cases };
+};
+export const respond = (module, input, self) => JSON.stringify(JSON.parse(input).map((request) => answer(module, request, self)));
+export function responsesOf(printed, asked) {
+    const last = /(?:^|\n)([^\n]*)$/.exec(printed.trimEnd())?.[1] ?? '';
+    const held = last.startsWith('[') ? JSON.parse(last) : [];
+    return Array.from({ length: asked }, (_, i) => held[i] ?? { protocol: PROTOCOL, kind: 'refuse', why: 'no answer' });
+}

package/dist/forms/alphabet.d.ts

@@ -0,0 +1,3 @@
+import { WideMask } from '@lapxo/obligations';
+import type { WireForm } from './form.ts';
+export declare const alphabetOfForm: WireForm<WideMask>;

package/dist/forms/alphabet.js

@@ -0,0 +1,19 @@
+import { alphabetForm, WideMask } from '@lapxo/obligations';
+import { alphabet } from "../wire/grammar.js";
+import { refuseForm, wordsAt, written } from "./form.js";
+const tokensOf = (params) => ({ tokens: wordsAt('alphabet', params, 'tokens') });
+export const alphabetOfForm = {
+    id: 'alphabet',
+    lattice: (params) => alphabetForm.lattice(tokensOf(params)),
+    parse(params, text) {
+        const { tokens } = tokensOf(params);
+        const read = alphabet(text);
+        const stray = read.members.find((one) => !tokens.includes(one));
+        if (stray !== undefined)
+            refuseForm('alphabet', `\`${stray}\` is not one of its tokens`);
+        return WideMask.fromTokens(tokens, new Set(read.polarity === 'forbid' ? tokens.filter((one) => !read.members.includes(one)) : read.members));
+    },
+    emit: (params, value) => written(value.members(tokensOf(params).tokens)),
+    show: (params, value) => alphabetForm.lattice(tokensOf(params)).show(value),
+    points: (params, seed, n) => alphabetForm.points(tokensOf(params), seed, n),
+};

package/dist/forms/budget.d.ts

@@ -0,0 +1,3 @@
+import type { Interval } from '@lapxo/obligations';
+import type { WireForm } from './form.ts';
+export declare const budgetForm: WireForm<Interval>;

package/dist/forms/budget.js

@@ -0,0 +1,11 @@
+import { continuousForm } from '@lapxo/obligations';
+import { bandOf, bandText, numberAt } from "./form.js";
+const span = (params) => ({ lo: numberAt('budget', params, 'lo'), hi: numberAt('budget', params, 'hi') });
+export const budgetForm = {
+    id: 'budget',
+    lattice: (params) => continuousForm.lattice(span(params)),
+    parse: (params, text) => bandOf('budget', span(params), text),
+    emit: (_params, value) => bandText(value),
+    show: (params, value) => continuousForm.lattice(span(params)).show(value),
+    points: (params, seed, n) => continuousForm.points(span(params), seed, n),
+};

package/dist/forms/distribution.d.ts

@@ -0,0 +1,3 @@
+import type { Unit } from '@lapxo/obligations';
+import type { WireForm } from './form.ts';
+export declare const distributionForm: WireForm<Unit>;

package/dist/forms/distribution.js

@@ -0,0 +1,36 @@
+import { latticeForm } from '@lapxo/obligations';
+import { alphabet } from "../wire/grammar.js";
+import { levelsOf, refuseForm, wordsAt, written } from "./form.js";
+/** A distribution is a product of levels by bucket: every tuple of one level per bucket, ordered bucket by bucket. */
+function product(params) {
+    const buckets = wordsAt('distribution', params, 'buckets');
+    const levels = wordsAt('distribution', params, 'levels');
+    const tuples = buckets.reduce((held) => held.flatMap((tuple) => levels.map((level) => [...tuple, level])), [[]]);
+    return { buckets, levels, tuples };
+}
+const orderOver = (params) => {
+    const { levels, tuples } = product(params);
+    const at = (tuple) => tuple.map((level) => levels.findIndex((one) => one === level));
+    return { levels: tuples.map((tuple) => JSON.stringify(tuple)), leq: tuples.map((low) => tuples.map((high) => at(low).every((rank, i) => rank <= (at(high)[i] ?? -1)))) };
+};
+export const distributionForm = {
+    id: 'distribution',
+    lattice: (params) => latticeForm.lattice(orderOver(params)),
+    parse(params, text) {
+        const { buckets, levels } = product(params);
+        const bucketOf = (part) => buckets.find((bucket) => !bucket.includes(':') && part.startsWith(`${bucket}:`));
+        const members = alphabet(text).members;
+        const said = new Map(members.flatMap((part) => ((bucket) => (bucket === undefined ? [] : [[bucket, part.slice(bucket.length + 1)]]))(bucketOf(part))));
+        const stray = members.find((part) => bucketOf(part) === undefined) ?? buckets.find((bucket) => !said.has(bucket));
+        if (stray !== undefined)
+            refuseForm('distribution', `\`${stray}\` is not the bucket list it is given, every bucket named once`);
+        const bands = buckets.map((bucket) => levelsOf('distribution', levels, said.get(bucket) ?? ''));
+        return { subject: '', floor: JSON.stringify(bands.map((band) => band.floor)), ceiling: JSON.stringify(bands.map((band) => band.ceiling)) };
+    },
+    emit(params, value) {
+        const [lows, highs] = [JSON.parse(value.floor), JSON.parse(value.ceiling)];
+        return written(product(params).buckets.map((bucket, i) => (lows[i] === highs[i] ? `${bucket}:${lows[i]}` : `${bucket}:${lows[i]}..${highs[i]}`)));
+    },
+    show: (params, value) => latticeForm.lattice(orderOver(params)).show(value),
+    points: (params, seed, n) => latticeForm.points(orderOver(params), seed, n),
+};

package/dist/forms/form.d.ts

@@ -0,0 +1,31 @@
+import type { Interval, Lattice, Unit } from '@lapxo/obligations';
+/**
+ * A form of the wire is how a line writes a value and the lattice of the algebra that value is read in: an id, the
+ * parameters that lattice takes, the text a line carries and the points every reading over forms samples. A form here
+ * orders nothing of its own; each hands over a lattice the algebra already offers, parametrised, and what a form would
+ * need that the algebra does not offer is the algebra's to add.
+ */
+export interface WireForm<T = unknown> {
+    readonly id: string;
+    lattice(params: unknown): Lattice<T>;
+    parse(params: unknown, text: string): T;
+    emit(params: unknown, value: T): string;
+    show(params: unknown, value: T): string;
+    points(params: unknown, seed: number, n: number): readonly T[];
+}
+export declare const violationsIn: (lattice: ReturnType<WireForm["lattice"]>, points: ReturnType<WireForm["points"]>) => readonly string[];
+type Fields = Readonly<Record<string, unknown>>;
+export declare const paramsOf: (params: unknown) => Fields;
+export declare function refuseForm(id: string, why: string): never;
+export declare function numberAt(id: string, params: unknown, name: string): number;
+export declare function wordsAt(id: string, params: unknown, name: string): readonly string[];
+export declare const written: (words: readonly string[]) => string;
+/**
+ * A band a line writes over an interval it is given: `lo..hi`, one end alone, `*` for an end left open, or `empty`.
+ * Its ends are read by the wire's own interval form, the one a claim's value is read by, and one end alone is that end twice.
+ */
+export declare function bandOf(id: string, whole: Interval, text: string): Interval;
+export declare const bandText: (value: Interval) => string;
+/** A band a line writes over levels it is given, `lo..hi` or one level alone: the band of them whose written text it is. */
+export declare function levelsOf(id: string, held: readonly string[], text: string): Unit;
+export {};

package/dist/forms/form.js

@@ -0,0 +1,42 @@
+import { violationsIn as lawsBrokenIn } from '@lapxo/obligations';
+import { alphabet } from "../wire/grammar.js";
+import { fromLine } from "../wire/claimline.js";
+import { byBytes, canonical } from "../wire/line.js";
+import { decimal } from "../wire/values.js";
+export const violationsIn = (lattice, points) => lawsBrokenIn(lattice, points);
+export const paramsOf = (params) => (params !== null && typeof params === 'object' ? params : {});
+export function refuseForm(id, why) {
+    throw new Error(`REFUSE·form ${id}: ${why}`);
+}
+export function numberAt(id, params, name) {
+    const held = paramsOf(params)[name];
+    if (typeof held !== 'number' || !isFinite(held))
+        refuseForm(id, `takes ${name} as a number, and a value it is not given is not invented`);
+    return held;
+}
+export function wordsAt(id, params, name) {
+    const held = paramsOf(params)[name];
+    if (!Array.isArray(held) || !held.length || held.some((one) => typeof one !== 'string'))
+        refuseForm(id, `takes ${name} as a list of words`);
+    return held;
+}
+export const written = (words) => alphabet({ polarity: 'permit', members: [...new Set(words)].sort(byBytes) });
+/**
+ * A band a line writes over an interval it is given: `lo..hi`, one end alone, `*` for an end left open, or `empty`.
+ * Its ends are read by the wire's own interval form, the one a claim's value is read by, and one end alone is that end twice.
+ */
+export function bandOf(id, whole, text) {
+    if (text === 'empty')
+        return { lo: whole.hi, hi: whole.lo };
+    const read = (value) => ((got) => (got.kind === 'fact' && got.value.bound.kind === 'interval' ? { lo: got.value.bound.lo ?? whole.lo, hi: got.value.bound.hi ?? whole.hi } : undefined))(fromLine(canonical({ form: 'interval', value }), null));
+    return read(text) ?? read(`${text}..${text}`) ?? refuseForm(id, `\`${text}\` is not a band: lo..hi or one end, each a number or *`);
+}
+export const bandText = (value) => ((end) => (value.lo > value.hi ? 'empty' : `${end(value.lo)}..${end(value.hi)}`))((n) => (isFinite(n) ? decimal(n) : '*'));
+/** A band a line writes over levels it is given, `lo..hi` or one level alone: the band of them whose written text it is. */
+export function levelsOf(id, held, text) {
+    if (held.some((level) => level.includes('..')))
+        refuseForm(id, 'a level holds no band mark `..`');
+    const band = held.flatMap((floor) => held.map((ceiling) => ({ subject: '', floor, ceiling }))).find(({ floor, ceiling }) => text === `${floor}..${ceiling}`)
+        ?? (text.includes('..') ? undefined : held.filter((level) => level === text).map((level) => ({ subject: '', floor: level, ceiling: level }))[0]);
+    return band ?? refuseForm(id, `\`${text}\` is not one of its levels, nor two of them as lo..hi`);
+}

package/dist/forms/index.d.ts

@@ -0,0 +1,12 @@
+import { alphabetOfForm } from './alphabet.ts';
+import { budgetForm } from './budget.ts';
+import { distributionForm } from './distribution.ts';
+import { intervalForm } from './interval.ts';
+import { ladderOfForm } from './ladder.ts';
+import { latticeOfForm } from './lattice.ts';
+import { phaseForm } from './phase.ts';
+import { rankForm } from './rank.ts';
+import { stretchForm } from './stretch.ts';
+export { violationsIn } from './form.ts';
+export type { WireForm } from './form.ts';
+export { alphabetOfForm, budgetForm, distributionForm, intervalForm, ladderOfForm, latticeOfForm, phaseForm, rankForm, stretchForm };

package/dist/forms/index.js

@@ -0,0 +1,11 @@
+import { alphabetOfForm } from "./alphabet.js";
+import { budgetForm } from "./budget.js";
+import { distributionForm } from "./distribution.js";
+import { intervalForm } from "./interval.js";
+import { ladderOfForm } from "./ladder.js";
+import { latticeOfForm } from "./lattice.js";
+import { phaseForm } from "./phase.js";
+import { rankForm } from "./rank.js";
+import { stretchForm } from "./stretch.js";
+export { violationsIn } from "./form.js";
+export { alphabetOfForm, budgetForm, distributionForm, intervalForm, ladderOfForm, latticeOfForm, phaseForm, rankForm, stretchForm };

package/dist/forms/interval.d.ts

@@ -0,0 +1,3 @@
+import type { Interval } from '@lapxo/obligations';
+import type { WireForm } from './form.ts';
+export declare const intervalForm: WireForm<Interval>;

package/dist/forms/interval.js

@@ -0,0 +1,11 @@
+import { continuousForm } from '@lapxo/obligations';
+import { bandOf, bandText, numberAt } from "./form.js";
+const span = (params) => ({ lo: numberAt('interval', params, 'lo'), hi: numberAt('interval', params, 'hi') });
+export const intervalForm = {
+    id: 'interval',
+    lattice: (params) => continuousForm.lattice(span(params)),
+    parse: (params, text) => bandOf('interval', span(params), text),
+    emit: (_params, value) => bandText(value),
+    show: (params, value) => continuousForm.lattice(span(params)).show(value),
+    points: (params, seed, n) => continuousForm.points(span(params), seed, n),
+};

package/dist/forms/ladder.d.ts

@@ -0,0 +1,3 @@
+import type { Unit } from '@lapxo/obligations';
+import type { WireForm } from './form.ts';
+export declare const ladderOfForm: WireForm<Unit>;

package/dist/forms/ladder.js

@@ -0,0 +1,11 @@
+import { ladderForm } from '@lapxo/obligations';
+import { levelsOf, wordsAt } from "./form.js";
+const over = (params) => ({ levels: wordsAt('ladder', params, 'levels') });
+export const ladderOfForm = {
+    id: 'ladder',
+    lattice: (params) => ladderForm.lattice(over(params)),
+    parse: (params, text) => levelsOf('ladder', over(params).levels, text),
+    emit: (_params, value) => (value.floor === value.ceiling ? value.floor : `${value.floor}..${value.ceiling}`),
+    show: (params, value) => ladderForm.lattice(over(params)).show(value),
+    points: (params, seed, n) => ladderForm.points(over(params), seed, n),
+};

package/dist/forms/lattice.d.ts

@@ -0,0 +1,3 @@
+import type { Unit } from '@lapxo/obligations';
+import type { WireForm } from './form.ts';
+export declare const latticeOfForm: WireForm<Unit>;