@lapxo/topos 0.1.0

package/dist/forms/lattice.js

@@ -0,0 +1,18 @@
+import { latticeForm } from '@lapxo/obligations';
+import { levelsOf, paramsOf, refuseForm, wordsAt } from "./form.js";
+/** An order a line names outright: its levels and, for each pair, whether the first lies under the second. */
+function orderOf(params) {
+    const levels = wordsAt('lattice', params, 'levels');
+    const leq = paramsOf(params)['leq'];
+    if (!Array.isArray(leq) || leq.length !== levels.length || leq.some((row) => !Array.isArray(row) || row.length !== levels.length))
+        refuseForm('lattice', 'takes leq as a square of truths over its levels');
+    return { levels, leq: leq };
+}
+export const latticeOfForm = {
+    id: 'lattice',
+    lattice: (params) => latticeForm.lattice(orderOf(params)),
+    parse: (params, text) => levelsOf('lattice', orderOf(params).levels, text),
+    emit: (_params, value) => (value.floor === value.ceiling ? value.floor : `${value.floor}..${value.ceiling}`),
+    show: (params, value) => latticeForm.lattice(orderOf(params)).show(value),
+    points: (params, seed, n) => latticeForm.points(orderOf(params), seed, n),
+};

package/dist/forms/phase.d.ts

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

package/dist/forms/phase.js

@@ -0,0 +1,11 @@
+import { continuousForm } from '@lapxo/obligations';
+import { bandOf, bandText, numberAt } from "./form.js";
+const span = (params) => ({ lo: numberAt('phase', params, 'lo'), hi: numberAt('phase', params, 'hi') });
+export const phaseForm = {
+    id: 'phase',
+    lattice: (params) => continuousForm.lattice(span(params)),
+    parse: (params, text) => bandOf('phase', 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/rank.d.ts

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

package/dist/forms/rank.js

@@ -0,0 +1,11 @@
+import { continuousForm } from '@lapxo/obligations';
+import { bandOf, bandText, numberAt } from "./form.js";
+const span = (params) => ({ lo: 0, hi: numberAt('rank', params, 'n') });
+export const rankForm = {
+    id: 'rank',
+    lattice: (params) => continuousForm.lattice(span(params)),
+    parse: (params, text) => bandOf('rank', 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/stretch.d.ts

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

package/dist/forms/stretch.js

@@ -0,0 +1,11 @@
+import { continuousForm } from '@lapxo/obligations';
+import { bandOf, bandText, numberAt } from "./form.js";
+const span = (params) => ({ lo: numberAt('stretch', params, 'lo'), hi: numberAt('stretch', params, 'hi') });
+export const stretchForm = {
+    id: 'stretch',
+    lattice: (params) => continuousForm.lattice(span(params)),
+    parse: (params, text) => bandOf('stretch', 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/readers/bindings.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Local, non-serialisable bindings. The descriptor travels; these stay here.
+ */
+import type { Claim, Outcome } from '../wire/types.ts';
+import type { FileInput, FormBody, ViewBody } from '../wire/classes.ts';
+interface ActivationContext {
+    readonly capabilities?: ReadonlySet<string>;
+    readonly store?: {
+        get(hash: string): {
+            readonly bytes: Uint8Array;
+        } | undefined;
+    };
+}
+export interface Bindings {
+    readonly readers?: Readonly<Record<string, (file: FileInput) => Outcome<readonly Claim[]>>>;
+    readonly accepts?: Readonly<Record<string, (place: string) => boolean>>;
+    readonly views?: Readonly<Record<string, ViewBody<unknown>>>;
+    readonly forms?: Readonly<Record<string, FormBody<unknown>>>;
+    readonly activate?: (context: ActivationContext) => unknown;
+}
+export {};

package/dist/readers/bindings.js

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

package/dist/readers/define.d.ts

@@ -0,0 +1,37 @@
+import type { Claim } from '../wire/types.ts';
+import type { ToposDescriptor } from '../wire/descriptor.ts';
+import type { Bindings } from './bindings.ts';
+/** A seen row has no origin: the SDK stamps by= and at= from what it handed over, and observe(bytes, digest) turns bytes into seen rows with no files, no store, no clock and no network. */
+type Seen = {
+    readonly scope: string;
+    readonly measure: string;
+    readonly role: Claim['role'];
+    readonly bound: Claim['bound'];
+    readonly unit?: string;
+};
+type Observe = (bytes: Uint8Array, digest: string) => readonly Seen[];
+export interface DefinedTopos {
+    readonly kind: 'defined';
+    readonly id: string;
+    readonly includes: readonly string[];
+    readonly members: readonly unknown[];
+    readonly claims: readonly Claim[];
+    readonly descriptor: ToposDescriptor;
+    readonly bindings: Bindings;
+    readonly domain?: readonly string[];
+    readonly observe?: Observe;
+}
+/** A region's cost is a fold of what was observed: the join of the spans its runs took, and none while it is only declared. */
+export declare const costOf: (observed: readonly (readonly [number, number])[]) => {
+    readonly cost?: readonly [number, number];
+};
+export declare function defineTopos(opts: {
+    readonly id: string;
+    readonly includes?: readonly string[];
+    readonly members?: readonly unknown[];
+    readonly by?: string;
+    readonly bindings?: Bindings;
+    readonly domain?: readonly string[];
+    readonly observe?: Observe;
+}): DefinedTopos;
+export {};

package/dist/readers/define.js

@@ -0,0 +1,59 @@
+/**
+ * A topos as a container. It lowers to an inert descriptor; it does not invent
+ * a fifth class or a universal composition law.
+ */
+import { intervals } from '@lapxo/obligations';
+import { claim } from "../wire/claim.js";
+import { emptyDescriptor } from "../wire/descriptor.js";
+const asClaim = (draft) => {
+    const judged = claim(draft);
+    if (judged.kind !== 'fact') {
+        throw new Error(judged.why);
+    }
+    return judged.value;
+};
+const SPANS = intervals(-Infinity, Infinity);
+/** A region's cost is a fold of what was observed: the join of the spans its runs took, and none while it is only declared. */
+export const costOf = (observed) => ((held) => (SPANS.inhabited(held) ? { cost: [held.lo, held.hi] } : {}))(observed.reduce((all, [lo, hi]) => SPANS.join(all, { lo, hi }), SPANS.bottom));
+export function defineTopos(opts) {
+    const by = opts.by ?? opts.id;
+    const includes = opts.includes ?? [];
+    const members = opts.members ?? [];
+    const claims = opts.observe
+        ? []
+        : [
+            asClaim({
+                scope: `topos/${opts.id}/class`,
+                measure: 'kind',
+                role: 'reads',
+                by,
+                at: opts.id,
+                bound: { kind: 'enumerated', values: ['readers'] },
+            }),
+            ...includes.map((ref) => asClaim({
+                scope: `topos/${opts.id}/includes`,
+                measure: 'id',
+                role: 'reads',
+                by,
+                at: opts.id,
+                bound: { kind: 'enumerated', values: [ref] },
+                reference: { rel: 'within', to: [`topos/${ref}`], by: 'declared' },
+            })),
+        ];
+    const descriptor = {
+        ...emptyDescriptor(opts.id),
+        includes,
+        claims,
+    };
+    return {
+        kind: 'defined',
+        id: opts.id,
+        includes,
+        members,
+        claims,
+        descriptor,
+        bindings: opts.bindings ?? {},
+        ...(opts.domain ? { domain: opts.domain } : {}),
+        ...(opts.observe ? { observe: opts.observe } : {}),
+    };
+}

package/dist/readers/index.d.ts

@@ -0,0 +1,3 @@
+/** It answers the world-neutral readers of lines — what does a line say? */
+export { costOf, defineTopos } from './define.ts';
+export type { DefinedTopos } from './define.ts';

package/dist/readers/index.js

@@ -0,0 +1,2 @@
+/** It answers the world-neutral readers of lines — what does a line say? */
+export { costOf, defineTopos } from "./define.js";

package/dist/wire/claim.d.ts

@@ -0,0 +1,4 @@
+import type { Claim, Outcome } from './types.ts';
+type ClaimDraft = Partial<Claim> & Pick<Claim, 'scope' | 'measure' | 'bound' | 'role'>;
+export declare function claim(draft: ClaimDraft): Outcome<Claim>;
+export {};

package/dist/wire/claim.js

@@ -0,0 +1,43 @@
+import { fact, refuse } from "./types.js";
+const ROLES = new Set(['reads', 'writes', 'demands']);
+const isPointBound = (b) => {
+    if (b.kind === 'interval')
+        return b.lo === b.hi;
+    if (b.kind === 'enumerated')
+        return b.values.length === 1;
+    return false;
+};
+const present = (value) => typeof value === 'string' && value.length > 0;
+export function claim(draft) {
+    if (!present(draft.scope))
+        return refuse('claim: scope is required');
+    if (!present(draft.measure))
+        return refuse('claim: measure is required');
+    if (draft.bound === undefined)
+        return refuse('claim: bound is required');
+    if (!present(draft.role) || !ROLES.has(draft.role)) {
+        return refuse(`claim: role must be reads, writes, or demands, not ${String(draft.role)}`);
+    }
+    if (!present(draft.by))
+        return refuse('claim: by is required');
+    if (!present(draft.at))
+        return refuse('claim: at is required');
+    if (draft.role === 'writes' && !isPointBound(draft.bound)) {
+        return refuse('claim: a write states one value');
+    }
+    const built = {
+        scope: draft.scope,
+        measure: draft.measure,
+        bound: draft.bound,
+        role: draft.role,
+        by: draft.by,
+        at: draft.at,
+        ...(draft.unit !== undefined ? { unit: draft.unit } : {}),
+        ...(draft.epoch !== undefined ? { epoch: draft.epoch } : {}),
+        ...(draft.multiplicity !== undefined ? { multiplicity: draft.multiplicity } : {}),
+        ...(draft.reference !== undefined ? { reference: draft.reference } : {}),
+        ...(draft.support !== undefined ? { support: draft.support } : {}),
+        ...(draft.extra !== undefined ? { extra: draft.extra } : {}),
+    };
+    return fact(built);
+}

package/dist/wire/claimline.d.ts

@@ -0,0 +1,78 @@
+import type { Outcome } from './outcome.ts';
+import type { Claim } from './types.ts';
+import type { FormGrammar } from './values.ts';
+import type { KeyClass } from '../authority/motion.ts';
+export declare const ENVELOPE: ReadonlySet<string>;
+interface Wire {
+    readonly epoch: number;
+    readonly fields: ReadonlySet<string>;
+    readonly required: ReadonlySet<string>;
+    readonly roles: ReadonlySet<string>;
+    readonly forms: ReadonlySet<string>;
+    readonly classes: ReadonlySet<string>;
+    readonly digests: ReadonlySet<string>;
+    readonly signatures: ReadonlySet<string>;
+    readonly formOf: ReadonlyMap<string, string>;
+    readonly lists: ReadonlyMap<string, ReadonlySet<string>>;
+}
+export declare function isWireClaim(fields: Readonly<Record<string, string>>): boolean;
+export declare function wireAt(lines: readonly Readonly<Record<string, string>>[], epoch: number): Wire | null;
+export declare function fromLine(text: string, wire: Wire | null, grammars?: readonly FormGrammar[]): Outcome<Claim>;
+export interface Signer {
+    readonly id: string;
+    readonly keyClass: KeyClass;
+    readonly publicKey: string;
+    readonly coverage: readonly string[];
+    readonly spans?: readonly {
+        readonly globs: readonly string[];
+        readonly from: number;
+        readonly to: number | null;
+    }[];
+    readonly depth: {
+        readonly lo: number;
+        readonly hi: number;
+    };
+    readonly admittedBy: readonly string[];
+    readonly epoch?: {
+        readonly start: number;
+        readonly close: number | null;
+    };
+    readonly windows?: readonly {
+        readonly lo: number;
+        readonly hi: number;
+        readonly from: number;
+        readonly to: number | null;
+    }[];
+}
+type Verify = (fields: Readonly<Record<string, string>>, publicKey: string) => boolean;
+export type SignerVerdict = {
+    readonly kind: 'admitted';
+    readonly signer: string;
+} | {
+    readonly kind: 'grey';
+    readonly why: string;
+} | {
+    readonly kind: 'refuse';
+    readonly why: string;
+    readonly named: string;
+};
+export declare function isKeyClaim(fields: Readonly<Record<string, string>>): boolean;
+export declare function windowAt(signer: Signer, epoch: number): {
+    readonly start: number;
+    readonly close: number | null;
+};
+export declare function signersOf(lines: readonly Readonly<Record<string, string>>[], root: Signer, verify: Verify): {
+    readonly admitted: readonly Signer[];
+    readonly potential: readonly string[];
+};
+export declare function authorityOf(fields: Readonly<Record<string, string>>, signers: readonly Signer[], verify: Verify): SignerVerdict;
+declare const COORDINATE_ROLES: readonly ["source", "derived", "observed", "foreign"];
+export type CoordinateRole = (typeof COORDINATE_ROLES)[number];
+export interface RoleClaim {
+    readonly name: string;
+    readonly role: CoordinateRole;
+}
+export declare function roleClaimsOf(lines: readonly Readonly<Record<string, string>>[]): readonly RoleClaim[];
+export declare function namesAt(at: string, name: string): boolean;
+export declare function roleAt(at: string, claims: readonly RoleClaim[]): CoordinateRole;
+export {};