@lapxo/bound 0.2.0 → 0.2.1

package/dist/cli/place.d.ts

@@ -1,76 +0,0 @@
-import type { ReleasePolicyResult } from '../fold/release-policy.ts';
-import type { Fork } from '../fold/claims.ts';
-import type { Packed } from '../fold/region.ts';
-import type { OpenCell } from '../render/open.ts';
-import type { SecondHead } from '../fold/second.ts';
-import { renderTarget } from '../render/target.ts';
-/**
- * Everything the fold knows about one place of the tree, or about the whole tree: what every region is rendered from,
- * whether it was read back from a key already answered rather than taken again, and the middle of the last ten folds
- * of this place, those that had to fold apart from those that read. A region whose points are ledger lines that move
- * at every beat is judged when it is read and never kept: a kept fold answers for the regions whose digest is in its
- * key and for no others.
- */
-export interface PlaceFold {
-    readonly release?: ReleasePolicyResult;
-    readonly root: string;
-    readonly store: string;
-    readonly under?: string;
-    readonly epoch: number;
-    readonly standing: readonly string[];
-    readonly claims: number;
-    readonly forks: readonly Fork[];
-    readonly grey: readonly string[];
-    readonly refused: readonly string[];
-    readonly vacuous: number;
-    readonly demands: readonly string[];
-    readonly paid: readonly string[];
-    readonly missing: readonly string[];
-    readonly history: readonly string[];
-    readonly observed: readonly string[];
-    readonly receiptHistory?: readonly string[];
-    readonly ceilings: {
-        readonly read: number;
-        readonly total: number;
-        readonly unread: readonly string[];
-        readonly vacuous: readonly string[];
-        readonly short: readonly string[];
-        readonly over: readonly string[];
-    };
-    readonly orphans: readonly string[];
-    readonly lock: number;
-    readonly signed: ReadonlyMap<string, number>;
-    readonly second: SecondHead;
-    readonly effects: string;
-    readonly costs: readonly number[];
-    readonly landed: number;
-    readonly kept?: boolean;
-    readonly key: string;
-    readonly instrument: string;
-    readonly own: Readonly<Record<string, number>>;
-    readonly open: readonly OpenCell[];
-    readonly beats: {
-        readonly kept: number;
-        readonly folded: number;
-    };
-    readonly regions?: Packed;
-}
-export declare function standingOf(root: string, under?: string, told?: readonly string[]): {
-    readonly standing: readonly string[];
-    readonly lock: readonly string[];
-    readonly rendered: ReturnType<typeof renderTarget>;
-    readonly owned: readonly string[];
-};
-export declare function coneOf(root: string, entry: string, ceilings: readonly string[], descent?: readonly string[]): {
-    readonly standing: readonly string[];
-    readonly observed: readonly string[];
-    readonly receiptHistory?: readonly string[];
-    readonly own: Readonly<Record<string, number>>;
-    readonly kept: boolean;
-};
-export declare const ownCeilings: (under?: string) => readonly string[];
-export declare function foldPlace(root: string, entry: string, under?: string, look?: boolean, given?: {
-    readonly standing: ReturnType<typeof standingOf>;
-    readonly observed?: readonly string[];
-    readonly free?: boolean;
-}): PlaceFold;

package/dist/cli/release-result.d.ts

@@ -1,5 +0,0 @@
-/** Judge an external signed approval without landing it, fetching its source,
- * executing a provider, or changing the release-policy verdict of the place.
- * The anchor is the place's key, never a key offered by the approval. */
-export declare function releaseApproval(lock: readonly string[], lines: readonly string[]): string;
-export declare function printReleaseApproval(root: string, file: string): void;

package/dist/cli/standing-result.d.ts

@@ -1,5 +0,0 @@
-/** An evidence projection, never a new authority lock. Authentication uses
- * the admission snapshot at each local epoch; the existing fold applies
- * supersessions and withdrawals across all declared classes. Storage layout
- * and delivery mode do not enter this public boundary. */
-export declare function printStandingResult(root: string): void;

package/dist/cli/takes.d.ts

@@ -1,30 +0,0 @@
-import { judgeTake } from '../judge/take.ts';
-import type { Gate } from '../judge/take.ts';
-export type Judged = {
-    readonly kind: 'refused';
-    readonly scope: string;
-    readonly why: string;
-} | {
-    readonly kind: 'owed';
-    readonly scope: string;
-    readonly why: string;
-} | {
-    readonly kind: 'conditioned';
-    readonly scope: string;
-    readonly demand: string;
-    readonly receipt: string;
-    readonly condition: string;
-} | {
-    readonly kind: 'judged';
-    readonly scope: string;
-    readonly demand: string;
-    readonly locations: readonly string[];
-    readonly before: ReadonlyMap<string, string>;
-    readonly after: ReadonlyMap<string, string>;
-    readonly verdict: ReturnType<typeof judgeTake>;
-    readonly ignored: ReadonlyMap<string, number>;
-    readonly started: number;
-};
-export declare function judgeDemand(root: string, demand: string): Judged;
-/** A take its batch let land: its receipt sealed with the gates the batch passed, its cone vouched, its fact landed. */
-export declare function landTake(root: string, one: Judged, gates: readonly Gate[]): void;

package/dist/fold/admission-history.d.ts

@@ -1,6 +0,0 @@
-import type { Signer } from '@lapxo/topos/wire';
-/** Local admission history only. Foreign ingress is evidence, never coverage.
- * The clock cutoff is meaningful for configuration; object clocks stay intact. */
-export declare function admissionHistoryAt(root: string, epoch: number): readonly string[];
-/** The existing bootstrap's public root of trust, not today's key selection. */
-export declare function admissionAnchor(root: string): Signer;

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, active?: readonly string[]): 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/object.d.ts

@@ -1,3 +0,0 @@
-/** Compatibility path; the engine owns the single object projection. */
-export { objectFold } from '../engine/index.ts';
-export type { ObjectReading } from '../engine/index.ts';

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;