@lapxo/bound 0.1.9 → 0.2.1

package/dist/fold/ceilings.d.ts

@@ -1,24 +0,0 @@
-type Side = 'short' | 'over';
-export interface CeilingFold {
-    readonly read: readonly string[];
-    readonly over: readonly {
-        readonly ceiling: string;
-        readonly question: string;
-        readonly got: string;
-        readonly side: Side;
-    }[];
-    readonly unread: readonly string[];
-    readonly vacuous: readonly string[];
-    readonly readings: ReadonlyMap<string, readonly string[]>;
-}
-export declare const answersElsewhere: (ceiling: string, own: Readonly<Record<string, number>>, under?: string, places?: ReadonlySet<string>) => boolean;
-export declare function foldCeilings(input: {
-    readonly standing: readonly string[];
-    readonly ceilings: readonly string[];
-    readonly observed: readonly string[];
-    readonly own: Readonly<Record<string, number>>;
-    readonly epoch: number;
-    readonly under?: string;
-    readonly places?: ReadonlySet<string>;
-}): CeilingFold;
-export {};

package/dist/fold/claims.d.ts

@@ -1,29 +0,0 @@
-import { parse } from '@lapxo/topos/wire';
-export { CAPSULE, EXTENSION, LOCK, RECEIPTS } from '@lapxo/topos/wire';
-/** Pure syntax is retained by the exact record bytes, never by a path, epoch or
- * claimed digest. This does not retain admission, coverage or current grants. */
-export declare function parsedLine(line: string): ReturnType<typeof parse>;
-export declare const fieldOf: (line: string, name: string) => string;
-export declare const fieldsOf: (line: string) => Record<string, string>;
-export declare function selfName(): string;
-export declare function isWire(line: string): boolean;
-export declare const wireLinesOf: (text: string | undefined) => readonly string[];
-export declare const isConfig: (line: string) => boolean;
-export declare const sayingOf: (line: string) => string;
-/** One key per claim: scope, role and measure; what a line says, its envelope set aside, is one however often it landed. */
-export declare function claimKey(line: string): string;
-export interface Fork {
-    readonly key: string;
-    readonly lines: readonly string[];
-    readonly state?: string;
-}
-export declare function foldClaims(lines: readonly string[], receipts?: readonly {
-    readonly scope: string;
-    readonly moved: readonly string[];
-}[], _placed?: boolean): {
-    readonly standing: readonly string[];
-    readonly superseded: readonly string[];
-    readonly retracted: readonly string[];
-    readonly forks: readonly Fork[];
-    readonly vacuous: readonly string[];
-};

package/dist/fold/closed.d.ts

@@ -1,15 +0,0 @@
-export declare const idleCount: () => number;
-export declare const noteIdle: () => void;
-export declare const actSeconds: () => number;
-export declare const receiptsSeen: () => {
-    readonly count: number;
-    readonly ms: number;
-};
-/** File-fold identity uses public inputs; admission history stays in its separate ledger guard. */
-export declare function fileRegionDigest(root: string, place: string, region: string, algorithm: string, inputs?: readonly string[]): string;
-export declare const instrumentKept: (store: string) => string;
-export declare function instrumentKeep(store: string, id: string): void;
-export declare function receiptPlaces(root: string, store: string): readonly string[];
-export declare function closeReceipts(root: string, store: string, semantic?: ReadonlyMap<string, string>): Promise<readonly string[]>;
-/** One comparison. A place meets its receipt; the root meets when every receipt it names meets. */
-export declare function meets(root: string, store: string, place: string, current?: boolean): boolean;

package/dist/fold/configures.d.ts

@@ -1,4 +0,0 @@
-/** Every reads line that configures nothing is a ceiling: a bound some reading has to meet. */
-export declare function isCeiling(line: string): boolean;
-/** A demand that names no place asks nothing of the tree: it tells a render what to write, and no take pays it. */
-export declare function asksThePlace(line: string): boolean;

package/dist/fold/digests.d.ts

@@ -1,29 +0,0 @@
-export declare const algorithmCost: () => number;
-/**
- * The signature algorithms this tree admits, and the one it signs with now: each carries its era after its name, the
- * wire's `era` line names the one that is current, and every other is history, read and never written again. A wire
- * that names no era signs with the one that carries a digest, which is how the first era was named.
- */
-export declare function signaturesOf(store: string, told?: readonly string[]): {
-    readonly admitted: readonly string[];
-    readonly era: string;
-};
-export declare function eraOf(standing: readonly string[]): {
-    readonly admitted: readonly string[];
-    readonly era: string;
-};
-export declare const bytesDigest: (store: string, bytes: Uint8Array) => string;
-export declare const fullDigest: (store: string, input: string | readonly string[]) => string;
-export declare function coordinateDigest(store: string, at: string): string | undefined;
-export declare function memoized(store: string, key: string, compute: () => string): string;
-/**
- * The digest of the instrument itself: the entry module and everything it imports, by their bytes, and the source of
- * every region its lock says it depends on, followed as far as those regions depend — code it runs as much as its own.
- * A region its own lock names a release for, laid where it needs it, is that release by digest: what it runs, never a
- * sibling rebuilt beside it.
- * A fold is a function of its points and the instrument is one of them, so a fold kept by another bound is another
- * origin's fold — readable as history, never as this instrument's own state.
- */
-export declare function instrumentOf(store: string, entry: string, standing?: readonly string[], root?: string, releases?: readonly string[]): string;
-export declare function instrumentDigest(store: string, entry: string, standing?: readonly string[], root?: string, releases?: readonly string[]): string;
-export declare function instrumentCoordinates(store: string, entry: string, standing?: readonly string[], root?: string, releases?: readonly string[], fresh?: boolean): ReadonlyMap<string, string>;

package/dist/fold/evidence.d.ts

@@ -1,32 +0,0 @@
-import type { VerdictObservation } from '@lapxo/topos/authority';
-/** The instrument maps an abstract relation to its declared snapshot vocabulary. Topos has no actor or origin policy. */
-export interface SnapshotInput {
-    readonly declared: boolean;
-    readonly expected: {
-        readonly set?: string;
-        readonly standing: string;
-        readonly epoch: number;
-    };
-    readonly statement?: {
-        readonly admitted: boolean;
-        readonly set: string;
-        readonly standing: string;
-        readonly epoch: number;
-    };
-    readonly priorDisagreement?: boolean;
-    readonly comparison?: {
-        readonly admitted: boolean;
-        readonly set: string;
-        readonly verdict: 'agrees' | 'forks';
-        readonly epoch: number;
-    };
-}
-export declare function snapshotVerdict(input: SnapshotInput): {
-    verdict: "none" | "grey" | "stale" | "agrees" | "forks";
-    external: boolean;
-    epoch: number;
-};
-/** This selector belongs to the instrument, not the SDK's abstract evidence contract. */
-export declare function attestationObservations(configuration: readonly Readonly<Record<string, string>>[], result: {
-    readonly verdict: string;
-}): readonly VerdictObservation[];

package/dist/fold/fold-worker.d.ts

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

package/dist/fold/kept.d.ts

@@ -1,29 +0,0 @@
-import type { PlaceFold } from '../cli/place.ts';
-/**
- * The points a fold folds: each coordinate the place holds at the digest its readers last read it, with what they said of
- * it there, the lines that stand, and the receipts the store keeps. A coordinate is never a digest it had before nor a coordinate
- * of another place, so an edit elsewhere moves nothing here; and a reader is what it said, so a reader edit that says
- * the same moves nothing either. A fold is a function of these points, so a fold that was not found is never a
- * mystery — what moved is the difference between the points kept beside the last one and the points there are now.
- */
-export type PlaceReads = {
-    readonly owned: readonly string[];
-    readonly scopes: ReadonlySet<string>;
-    readonly place: string;
-};
-export declare function foldPoints(store: string, standing: readonly string[], under: string | undefined, keeper?: string, instrument?: string, observed?: readonly string[], root?: string, answered?: ReadonlyMap<string, string>, reads?: PlaceReads): readonly string[];
-/**
- * What a reader said at one digest, as one digest: every point of a fold that stands for an answer is this. The writer
- * whose class the lock names live is judged when read, so a fold keeps what it said — which lines it found standing and
- * which ledger it folded — and not when.
- */
-export declare const saidDigest: (store: string, lines: readonly string[]) => string;
-export declare function movedPoints(store: string, now: readonly string[], key: string): {
-    readonly gone: readonly string[];
-    readonly came: readonly string[];
-} | undefined;
-export declare const foldsElsewhere: () => number;
-export declare function keptPlace(store: string, under?: string, currentInstrument?: string): PlaceFold | undefined;
-export declare const keptRender: (store: string, key: string, name: string) => string | undefined;
-export declare const keepRender: (store: string, _signer: string, key: string, name: string, _epoch: number, text_: string) => void;
-export declare function keepFold(store: string, key: string, fold: PlaceFold, points: readonly string[], instrument?: string): void;

package/dist/fold/keys.d.ts

@@ -1,17 +0,0 @@
-/**
- * Whose lines carry a class of writing, as the lock says it. Every ledger the store keeps is read, the key claims
- * folded, and the class answered with the id the lock admitted first for it: no module here holds a signer's name, so
- * the day another head runs the same work its lines come out under its own name without a letter changing.
- */
-export declare const keyOf: (store: string, kind: string, told?: readonly string[]) => string | undefined;
-export declare function keyFor(store: string, kind: string, told?: readonly string[]): string;
-export declare function lockSigners(store: string, told?: readonly string[]): readonly string[];
-export declare function lockLines(store: string): readonly string[];
-/** What stands of the lock, folded once per landing of any of its ledgers: lockLines is the bytes, lockSigners the ids that write them, signedLockLines the same lines still carrying their signatures. */
-export declare function lockStanding(store: string): readonly string[];
-export declare function signedLockLines(store: string, told?: readonly string[]): string[];
-/**
- * A release's lock, where the store signs no key of its own: the lock as it was laid is the place's only lines, read
- * and never written. What it says is true where a pin names the release; no ledger is made of it.
- */
-export declare function releaseOf(store: string): readonly string[] | undefined;

package/dist/fold/laid.d.ts

@@ -1,17 +0,0 @@
-/**
- * A release is named by the digest of its folder, and what is laid is read again from its bytes by the same method: every
- * coordinate but those the tree's roles call foreign, a dotted one only where the folder's own lock writes into it, sorted, each a
- * ustar entry of mode 0644, owner 0 and time 0, then two empty blocks, gzipped at level nine. The mark the host writes is
- * none of those coordinates, so the digest of a place is the digest of the release laid there, or it is not that release.
- */
-export declare function releaseDigest(store: string, place: string): {
-    readonly state: string;
-    readonly digest: string;
-};
-/**
- * What the pass lands after it lays: for each release the own lock lays where it needs it, the digest its bytes give, by
- * the stamps of the bytes it read. What is read is the receipt of the bytes as they lie now: none is a count, and one
- * whose digest is not the one the lock names is a count.
- */
-export declare function landLaid(store: string, own: string, lock: readonly string[], folder: string | undefined): void;
-export declare const laidDiffers: (store: string, own: string, lock: readonly string[], folder: string | undefined) => number;

package/dist/fold/nos.d.ts

@@ -1,8 +0,0 @@
-/**
- * A bug found lands as a no of the law it broke. From the epoch the lock asks for it on — the next one while no line
- * asks yet, the epoch an accept would sign it at — every law of the place a witness names, a demand or a ceiling, holds
- * its bug in a no: a need under the wire's sample family /<area>/no/, or a no of the place named after the law. What this
- * counts is each law witnessed since then that holds none. When the lock lists no sample family, every such law is a
- * demand: the folder is not guessed.
- */
-export declare function bugsWithoutANo(root: string, store: string, standing: readonly string[], place: string, measure: string): number;

package/dist/fold/observed.d.ts

@@ -1,35 +0,0 @@
-export declare const cased: (question: string) => boolean;
-export declare function isReaderLock(line: string): boolean;
-export declare function readerModules(store: string): readonly string[];
-type Placed = {
-    readonly question: string;
-    readonly measure: string;
-    readonly value: string;
-    readonly place: string;
-    readonly by: string;
-    readonly at: string;
-};
-export declare function placedReadings(observed: readonly string[]): readonly Placed[];
-export declare function casesHeld(observed: readonly string[]): number;
-export declare const readersBehind: () => readonly {
-    readonly module: string;
-    readonly places: number;
-}[];
-export declare const readerRefusals: () => readonly string[];
-export declare function readerLines(store: string): readonly string[];
-/**
- * A reader never blocks a fold that did not ask to wait: what it read before is served at once, and a reader whose
- * identity is new, or whose places moved, is grey by name and runs behind the fold. A fold that judges waits. A fold
- * that reaches only some regions observes only those, and a place with no reader reads what it carries.
- */
-export declare const carriesOnly: (root: string, store: string) => boolean;
-/** A reader whose `needs` meet the reach runs, wherever its module lives. The module path is not the region it reads. */
-export declare function readerReaches(reach: readonly string[] | undefined, where: readonly string[]): boolean;
-export declare function observedClaims(root: string, store: string, options?: {
-    readonly wait?: boolean;
-    readonly only?: string;
-    readonly reach?: readonly string[];
-    readonly answered?: Map<string, string>;
-    readonly selected?: string;
-}): readonly string[];
-export {};

package/dist/fold/opened.d.ts

@@ -1,5 +0,0 @@
-/**
- * What one landed line opens inside its place: a region whose reads cover the line's scope, a view whose shape covers
- * it, and the scope's own tail. Every other region stays on its receipt at one step.
- */
-export declare function openedBy(places: readonly string[], standing: readonly string[], lines: readonly string[]): readonly string[];

package/dist/fold/own.d.ts

@@ -1,24 +0,0 @@
-import type { CoordinateRole } from './wire.ts';
-type RoleOf = (coordinate: string) => CoordinateRole;
-export declare const outsideTheirCapsule: (root: string, standing: readonly string[], lines: readonly string[]) => readonly string[];
-/**
- * What the instrument reads of itself rather than through a reader: how many programs its source opens, how many
- * signed lines stand unadmitted, how many stores it keeps, which of the modules it runs are no source, how many samples
- * nothing names, how many alphabets are spelled both in code and in the lock, and how many regions it writes that no
- * line of the lock describes, how many bodies are written twice anywhere in the tree rather than once and used by
- * digest, and whether the version a package carries is the one the lock names. Inside one package, only what lies
- * there. A cost is read now and never read back from the fold it was taken with: a beat is a line of the ledger.
- */
-export declare function costReadings(store: string, standing: readonly string[], under?: string): Readonly<Record<string, number>>;
-export declare function ownReadings(input: {
-    readonly root: string;
-    readonly store: string;
-    readonly entry: string;
-    readonly roleOf: RoleOf;
-    readonly standing: readonly string[];
-    readonly observed: readonly string[];
-    readonly unadmitted: number;
-    readonly orphans: number;
-    readonly under?: string;
-}): Readonly<Record<string, number>>;
-export {};

package/dist/fold/paid.d.ts

@@ -1,11 +0,0 @@
-import { state } from '@lapxo/obligations/views/field';
-import type { PlaceFold } from '../cli/place.ts';
-/** Where a case lies: a demand is judged only over a cone that holds one, by a take or read from a landed cone alike. */
-export declare const holdsCases: (location: string) => boolean;
-export declare function paidOf(store: string, demands: readonly string[], observed: readonly string[], views: string): {
-    readonly paid: readonly string[];
-    readonly missing: readonly string[];
-    readonly answered: ReadonlySet<string>;
-};
-export type Verdict = ReturnType<typeof state>;
-export declare const verdictsFor: (fold: PlaceFold) => Readonly<Record<string, Verdict>>;

package/dist/fold/place-inputs.d.ts

@@ -1,17 +0,0 @@
-import { type View } from '../fold/views.ts';
-import type { PlaceFold } from '../cli/place.ts';
-/**
- * A place seen from inside it: the wire and the keys it is read with, the regions it is written in, and every line of
- * the place — its manifest, its build, its pages, its prose, its own ceilings and every line a view of it reads. Nothing
- * of the tree's history, and nothing the instrument keeps for itself, crosses; a need outside the place is left behind.
- * A capsule renders a place from these lines, in the tree as in the place published alone, so both write one coordinate; the
- * lock a place is rendered with is these lines as target lines its first land signs at epoch one, the bootstrap first.
- * A view is the place's own: a line of it that names coordinates is taken when one of them is a coordinate of the place, and a
- * line that names none where its view names this place or no place at all, or at a world that holds no line of a view
- * the views/world list names. A line another published place leads is taken only by its needs.
- */
-export declare function takenFor(held: readonly string[], under: string, world?: {
-    readonly own: readonly string[];
-    readonly tree: ReadonlyMap<string, View>;
-}): (line: string) => boolean;
-export declare function placeLines(fold: Pick<PlaceFold, 'root' | 'standing' | 'under'>): readonly string[];

package/dist/fold/places.d.ts

@@ -1,24 +0,0 @@
-type Spoken = {
-    readonly place: string;
-    readonly line: string;
-};
-/** A dependency's lock describes the dependency, never a child of its host.
- * Retiring a mount does not turn its retained bytes into local declarations. */
-export declare function mountedCoordinatesIn(root: string, history?: readonly string[]): readonly string[];
-export declare function localDirectoriesIn(root: string, history?: readonly string[]): readonly string[];
-export declare function placesIn(root: string, history?: readonly string[]): readonly string[];
-/** A directory with no own lock is founded by the root: a line of its region family names the directory's coordinates, and a covered batch that names the place lands its first own lock. */
-export declare const foundableIn: (root: string, standing: readonly string[], family: string, name: string) => boolean;
-export declare const capsuleAt: (root: string, name: string) => boolean;
-/** A world is a place whose own lock names capsule/key. A view named by wire/views/world resolves into these and no other place. */
-export declare const worldAt: (root: string, name: string) => boolean;
-export declare const worldsIn: (root: string) => readonly string[];
-export declare function kindsOf(root: string, place: string): readonly string[];
-type ClassDefault = {
-    readonly classes: readonly string[];
-    readonly line: string;
-};
-export declare function classDefaults(root: string): readonly ClassDefault[];
-export declare const fromPlace: (place: string, places: readonly string[]) => (path: string) => string;
-export declare function spoken(root: string): readonly Spoken[];
-export {};

package/dist/fold/rank.d.ts

@@ -1,3 +0,0 @@
-import type { PlaceFold } from '../cli/place.ts';
-/** What rests on a signed line: the rank of a signature is the lines that would move with it and nothing else. */
-export declare function rankLines(fold: PlaceFold): readonly string[];

package/dist/fold/reach.d.ts

@@ -1,18 +0,0 @@
-import type { Capsule } from '../host/capsule.ts';
-export declare const placedAt: (places: readonly string[], line: string) => string | undefined;
-export declare function touchedBy(root: string, places: readonly string[], lines: readonly string[], standing: readonly string[]): readonly string[];
-/** A selected world can execute only its explicit capsule offers. Dependency aliases are host projections, not selections. */
-export declare const selectionLines: (fold: {
-    readonly root: string;
-    readonly standing: readonly string[];
-    readonly under?: string;
-}) => readonly string[];
-export declare const projectionLines: (fold: {
-    readonly root: string;
-    readonly standing: readonly string[];
-    readonly under?: string;
-}) => readonly string[];
-export declare function capsulesFor(standing: readonly string[], place: string, root?: string): readonly {
-    readonly capsule: Capsule;
-    readonly offer: string;
-}[];

package/dist/fold/readers.d.ts

@@ -1,47 +0,0 @@
-import type { Capsule } from '../host/capsule.ts';
-import type { CoordinateRole } from './wire.ts';
-import { capsulesFor } from './reach.ts';
-import type { Kind } from '../observe/run.ts';
-export interface ReaderClaim {
-    readonly id: string;
-    readonly shape: readonly string[];
-    readonly where: readonly string[];
-    readonly module: string;
-    readonly kind: Kind;
-    readonly capsule?: {
-        readonly selected?: Capsule;
-        readonly digest: string;
-        readonly entry: string;
-        readonly region: string;
-        readonly reads: readonly string[];
-        readonly globs: ReadonlyMap<string, readonly string[]>;
-    };
-}
-export type Offer = {
-    readonly place: string;
-    readonly seen: string;
-    readonly bytes: () => Uint8Array;
-    readonly digest?: () => string;
-};
-export type Look = {
-    readonly under: (dir: string, pruned: boolean) => readonly string[];
-    readonly stamp: (at: string) => string;
-};
-export declare function lookOf(root: string, roleOf: (coordinate: string) => CoordinateRole): Look;
-/**
- * The reader regions of the capsules a place can run, where the place's own lock offers them or, at a world, the wire's offers/world list does for a
- * region its own lock does not name: each selected capsule that writes a declared region reads the coordinates
- * it declares among the place's offered coordinates. Selection identifies attribution, never independence.
- * An existing reader suppresses only that same selected provider, region and place; an ambiguous legacy
- * owner refuses instead of hiding another provider or invoking the same provider twice.
- * A newly declared region does not need a retired reader in private history to be observed.
- */
-export declare function capsuleReadersOf(root: string, store: string, standing: readonly string[], lines: readonly ReaderClaim[], resolve?: typeof capsulesFor): readonly ReaderClaim[];
-export declare function handedAt(root: string, reader: ReaderClaim, roleOf: (coordinate: string) => CoordinateRole, look: Look, place: string): readonly string[];
-/**
- * What a reader is offered at the places it reads: a coordinate for a reader of coordinates, the listing for one that reads a
- * directory, and for one that runs over its place its sources and every coordinate its shape names besides — a coordinate a view
- * writes from what readers said is offered only when named, so no reading moves its own offer — each by the stamp it
- * was seen at and the bytes that key what it said; a capsule reader is offered the coordinates it is handed.
- */
-export declare function offersOf(root: string, store: string, reader: ReaderClaim, roleOf: (coordinate: string) => CoordinateRole, look: Look, into: (where: string) => boolean): readonly Offer[];

package/dist/fold/receipts.d.ts

@@ -1,8 +0,0 @@
-/** A receipt as the fold sees it: the scope it paid and the coordinates it moved. */
-interface Receipt {
-    readonly scope: string;
-    readonly digest: string;
-    readonly moved: readonly string[];
-}
-export declare function receiptsIn(store: string, scopes?: readonly string[]): readonly Receipt[];
-export {};

package/dist/fold/region-declarations.d.ts

@@ -1,2 +0,0 @@
-/** Region input selectors consumed by the host, rather than measured ceilings. */
-export declare function isRegionDeclaration(line: string, wire: readonly string[]): boolean;

package/dist/fold/region.d.ts

@@ -1,72 +0,0 @@
-import type { Interval } from '@lapxo/obligations/forms';
-/**
- * A region is a prefix of the place, read at a resolution: the prefixes a lock already names — the steps a role, a
- * directory or a need is given at — are its regions, a cell belongs to the longest of them that holds it, and a region
- * rests on the region its prefix extends. A signature or a requirement is a line at the region its scope names, never a
- * value copied into the cells there; a cell's poles are the meet of the live bounds on its chain of rest, met in the
- * lattice of their form. Each region carries a summary of what lies in it, summed over the regions that rest on it —
- * cells, the sums and the values they read at the lattice's own resolution, the bounds signed at it — so what a bound
- * would bite is read off a summary without visiting a cell, and two readings of one place differ exactly in the regions
- * whose summaries differ. Nothing here is kept between folds; a region is read from the lines that stand and the cells seen.
- */
-export interface Bound {
-    readonly line: string;
-    readonly question: string;
-    readonly region: string;
-    readonly measure: string;
-    readonly form: string;
-    readonly value: string;
-}
-export interface Regions {
-    readonly named: readonly string[];
-    readonly bounds: readonly Bound[];
-    readonly summaries: ReadonlyMap<string, {
-        readonly region: string;
-        readonly cells: number;
-        readonly sums: ReadonlyMap<string, number>;
-        readonly values: ReadonlyMap<string, ReadonlyMap<string, number>>;
-        readonly bounds: readonly Bound[];
-    }>;
-}
-export declare function regionsNamed(standing: readonly string[]): readonly string[];
-export declare function boundOf(named: readonly string[], line: string): Bound;
-/**
- * The poles of a region, question by question: each live bound is signed at the region it names and travels by rest, as
- * the object signs, so the ceiling is what the region reads up its chain of rest, the meet in the lattice of their form, and beside it what the region's cells hold under that question,
- * value by count. Read off the summaries alone; no cell is visited.
- */
-export declare function polesOf(regions: Regions, region: string): ReadonlyMap<string, {
-    readonly ceiling: Interval | readonly string[] | undefined;
-    readonly held: ReadonlyMap<string, number> | undefined;
-}>;
-export declare function regionsOf(standing: readonly string[], ceilings: readonly string[], cells: readonly {
-    readonly question: string;
-    readonly measure: string;
-    readonly value: string;
-    readonly place: string;
-}[]): Regions;
-/**
- * What a bound bites, read off the summary of its region and never off a cell: the values its region's cells read that
- * lie outside it, and of those the ones every bound above it still admits. A question finer than a summary is not asked.
- */
-export declare function rankOf(regions: Regions, bound: Bound, own?: Readonly<Record<string, number>>): {
-    readonly bars: number;
-    readonly cells: number;
-    readonly fresh: number;
-    readonly met: number;
-    readonly sums: number;
-};
-export declare function finerOf(regions: Regions): ReadonlyMap<string, readonly string[]>;
-export declare function digestsOf(regions: Regions): ReadonlyMap<string, string>;
-export declare function differing(a: Regions, b: Regions): {
-    readonly regions: readonly string[];
-    readonly compared: number;
-};
-export interface Packed {
-    readonly named: readonly string[];
-    readonly bounds: readonly string[];
-    readonly summaries: readonly (readonly [string, number, readonly (readonly [string, number])[], readonly (readonly [string, readonly (readonly [string, number])[]])[]])[];
-}
-export declare const packRegions: (regions: Regions) => Packed;
-export declare function unpackRegions(packed: Packed): Regions;
-export declare function unlikeReplay(regions: Regions, red: ReadonlySet<string>, own: Readonly<Record<string, number>>): number;

package/dist/fold/release-policy.d.ts

@@ -1,67 +0,0 @@
-import type { VerdictDemand, VerdictObservation } from '@lapxo/topos/authority';
-type CeilingReading = {
-    readonly read: readonly string[];
-    readonly unread: readonly string[];
-    readonly vacuous: readonly string[];
-    readonly over: readonly {
-        readonly ceiling: string;
-        readonly question: string;
-        readonly got: string;
-        readonly side: 'short' | 'over';
-    }[];
-};
-export interface ReleasePolicyInput {
-    /** Standing already admitted by the same fold. This function does not admit lines. */
-    readonly verdicts?: readonly VerdictObservation[];
-    readonly standing: readonly string[];
-    readonly demands: readonly string[];
-    readonly paid: readonly string[];
-    readonly ceilings: readonly string[];
-    readonly readings: CeilingReading;
-    readonly snapshot: {
-        readonly fold: string;
-        readonly instrument: string;
-    };
-    readonly faults?: readonly {
-        readonly kind: string;
-        readonly evidence: readonly string[];
-        readonly obligation?: string;
-    }[];
-}
-export interface ReleasePolicyResult {
-    readonly gates?: readonly VerdictDemand[];
-    readonly status: 'absent' | 'incomplete' | 'blocked' | 'ready';
-    readonly snapshot: ReleasePolicyInput['snapshot'];
-    readonly policy: readonly string[];
-    readonly categories: readonly {
-        readonly name: string;
-        readonly links: readonly string[];
-        readonly selected: readonly string[];
-        readonly failures: readonly {
-            readonly line: string;
-            readonly reason: string;
-            readonly evidence: readonly string[];
-        }[];
-    }[];
-    readonly unresolved: readonly string[];
-    /** All obligations, including those not selected; the normal fold keeps their verdicts. */
-    readonly debt: readonly string[];
-}
-/** Preserve actual fold faults; none gets a release category from its spelling. */
-export declare function releaseFaults(fold: {
-    readonly forks: readonly {
-        readonly key: string;
-        readonly lines: readonly string[];
-    }[];
-    readonly refused: readonly string[];
-    readonly grey: readonly string[];
-    readonly orphans: readonly string[];
-    readonly second: {
-        readonly verdict: string;
-    };
-}): NonNullable<ReleasePolicyInput['faults']>;
-/** Select declared obligations, never categories inferred from their names or paths. */
-export declare function releasePolicy(input: ReleasePolicyInput): ReleasePolicyResult;
-/** Existing fold output can show the policy without a new view or a release action. */
-export declare function releasePolicyLines(result: ReleasePolicyResult | undefined): readonly string[];
-export {};

package/dist/fold/resolved.d.ts

@@ -1,18 +0,0 @@
-import type { PlaceFold } from '../cli/place.ts';
-export declare const bytesOnly: (line: string) => string;
-/**
- * Every receipt of a place, @8: the bytes of what it observed that a reading ran over, those readings, the verdicts its
- * paid demands were taken with, and at the root the digest of each place's own receipts. The attest is none of them:
- * it stands in the root lock and the release, naming the root these lines resolve to. The fold keeps the set in the
- * root's store under the digest of its bytes, which every line that resolves it names, and what a place with no reader
- * carries is read back from there, never from a file the place ships.
- */
-export declare function receiptsOf(fold: PlaceFold): readonly string[];
-export declare function keepCarried(store: string, lines: readonly string[], from?: string): string;
-/**
- * What a copy of a place reads back of its receipts: the lines it shipped when they are the whole set, or, when they
- * name a root at the digest of its bytes, the set the store keeps there; a root the store does not keep is no set, and
- * the caller refuses rather than read the lines that only name it.
- */
-export declare function carriedFrom(store: string, shipped: readonly string[]): readonly string[] | undefined;
-export declare const carriedIn: (store: string) => readonly string[];

package/dist/fold/roles.d.ts

@@ -1,17 +0,0 @@
-import type { RoleClaim } from '@lapxo/topos/wire';
-import type { CoordinateRole } from './wire.ts';
-/** A lock line that gives a coordinate its role: every walk of the tree reads it. */
-export declare function isRoleLock(line: string): boolean;
-/** A lock the owner signs by digest and a capsule writes: its lines stand while the bytes are the ones that were signed. */
-export declare function inheritedRoles(store: string): {
-    readonly claims: readonly RoleClaim[];
-    readonly stale: readonly string[];
-};
-/**
- * What each coordinate of the tree is: the capsule that knows a world writes the roles of that world, the owner signs the
- * capsule's lock by digest, and this fold reads both. The instrument reads claims and never a name, and a coordinate no
- * standing claim names is source. The steps a walk must not enter are read the same way: the claims that name a whole
- * folder foreign or derived, as a set the walk can ask in one step instead of matching every claim at every step.
- */
-export declare function stepsOutside(store: string): ReadonlySet<string>;
-export declare function rolesOf(store: string): (coordinate: string) => CoordinateRole;

package/dist/fold/second.d.ts

@@ -1,18 +0,0 @@
-export interface SecondHead {
-    /** What its latest word says of this fold: the same lines stand, other lines stand, it read another ledger, its key is not admitted, or it never spoke. */
-    readonly verdict: 'agrees' | 'forks' | 'stale' | 'grey' | 'none';
-    /**
-     * A head counts as an origin of its own only once it has disagreed: until then it may be this one again (L16); and
-     * the epoch of its latest word, wherever it said it, which a clone reads as history and not as its own.
-     */
-    readonly external: boolean;
-    readonly epoch: number;
-    readonly apart?: readonly string[];
-}
-/**
- * The second head's word, read against this fold. It attests the digest of the lines it found standing and the digest
- * of the lines of the ledger it folded, in whatever order a store landed them, so a clone that lands the same lines
- * agrees; agreement is an encounter, disagreement a fork. A word about another lock is not read as this one's: the head
- * bound's own lock names is asked now over the ledger as it stands, with no key, and what it says is read, never kept.
- */
-export declare function secondHead(store: string, standing: readonly string[], admitted: (line: string) => boolean, owned?: readonly string[]): SecondHead;