@lapxo/bound 0.2.0 → 0.2.1

package/dist/land/withdraw.d.ts

@@ -1,14 +0,0 @@
-interface Withdrawal {
-    /** The held lines the withdrawals take. */
-    readonly taken: readonly string[];
-    /** Taken lines whose scale is distributive: withdrawing them loses nothing and keeps nothing. */
-    readonly exact: readonly string[];
-    readonly inexact: readonly string[];
-    readonly open: readonly string[];
-}
-export declare function retractedTogether(signed: readonly string[]): readonly {
-    readonly withdraw: string;
-    readonly line: string;
-}[];
-export declare function withdrawal(withdraws: readonly string[], held: readonly string[]): Withdrawal;
-export {};

package/dist/observe/files.d.ts

@@ -1,14 +0,0 @@
-export declare const observeFile: (at: string) => Uint8Array | undefined;
-export declare const observeText: (at: string) => string | undefined;
-export declare const exists: (at: string) => boolean;
-export type Kind = 'file' | 'dir' | 'link' | 'other';
-export declare function stampOf(at: string): {
-    readonly kind: Kind;
-    readonly stamp: string;
-} | undefined;
-export declare const linkOf: (at: string) => string;
-export declare function entriesIn(at: string): readonly {
-    readonly name: string;
-    readonly dir: boolean;
-}[];
-export declare function coordinatesUnder(dir: string, root: string, into?: (step: string) => boolean): string[];

package/dist/observe/identity.d.ts

@@ -1,21 +0,0 @@
-import type { ReaderLifetime } from '@lapxo/topos/wire';
-import type { Kind } from './run.ts';
-/** Where a reader's vectors lie: in its package, beside its source, under the name of its module, the folder the wire's vector family names. */
-export declare const vectorsOf: (module: string, standing: readonly string[]) => string;
-export declare const withoutVectors: (root: string, modules: readonly string[], standing: readonly string[]) => number;
-export declare function resetsOnEqualEmits(lines: readonly string[]): number;
-/** The executable keys the reader; its vector results describe only the cases measured. */
-export declare function identityOf(input: {
-    readonly store: string;
-    readonly root: string;
-    readonly speaker: string;
-    readonly module: string;
-    readonly kind: Kind;
-    readonly code: string;
-    readonly lineage: readonly string[];
-    readonly kept: readonly string[];
-    readonly lifetime?: ReaderLifetime;
-}): {
-    readonly by: string;
-    readonly lines: readonly string[];
-};

package/dist/observe/match.d.ts

@@ -1 +0,0 @@
-export declare const fits: (read: string, coordinate: string) => boolean;

package/dist/observe/regions.d.ts

@@ -1,33 +0,0 @@
-export { selectionLines } from '../fold/reach.ts';
-import type { Declaration } from '@lapxo/topos/capsule';
-import type { Request } from '@lapxo/topos/contract';
-import type { Capsule } from '../host/capsule.ts';
-import type { PlaceFold } from '../cli/place.ts';
-type Asking = {
-    readonly name: string;
-    readonly at: number;
-};
-type Placed = Pick<PlaceFold, 'root' | 'store' | 'standing' | 'observed'> & {
-    readonly under?: string;
-    readonly second?: PlaceFold['second'];
-};
-/** A declared selector keeps its contract token while the host binds only offered, concretely named regions. */
-export declare function regionNames(reads: readonly string[], descriptions: readonly string[]): readonly string[];
-export declare const describedReceipts: () => readonly string[];
-/** Execution is supplied only by explicit capsule offers of the selected standing. */
-export declare function capsulesOf(fold: Placed): readonly Capsule[];
-export declare const declaredBy: (fold: Placed) => readonly string[];
-type Ask = (declaration: Declaration, one: Asking, verb: 'render' | 'read', shape: string) => Request | undefined;
-/**
- * What a region of a capsule is handed: of the reads its line declares, every read of the place's lines, and each region
- * a line of the instrument's lock describes, with its lines and its receipts; a region no line describes is not handed,
- * and a region handed less than it declares is refused by its capsule, which is every capsule's no. Nothing is handed
- * as a file: the lines are the place as its published lock holds them, and each region is read once for the fold,
- * however many views ask it.
- */
-export declare const askingOf: (fold: Placed) => Ask;
-export declare function capsuleReadingsOver(fold: Placed): readonly string[];
-/** Current judgement excludes authenticated outcomes of the selected producer batches; retained evidence stays in its carrier. */
-export declare const currentReceiptObservations: (fold: Parameters<typeof capsulesOf>[0]) => readonly string[];
-/** Preserve prior producer outcomes in the owning place's public carrier, independently of current judgement. */
-export declare const retiredReceiptHistory: (fold: Parameters<typeof capsulesOf>[0]) => readonly string[];

package/dist/observe/run.d.ts

@@ -1,31 +0,0 @@
-import type { ReaderLifetime } from '@lapxo/topos/wire';
-export type Kind = 'js' | 'process';
-/** The kinds this host starts. A reader of any other kind is signed and stays potential: nothing here runs it. */
-export declare const runs: (kind: string) => kind is Kind;
-interface Row {
-    readonly scope: string;
-    readonly measure: string;
-    readonly role: string;
-    readonly bound: {
-        readonly kind: string;
-        readonly values?: readonly string[];
-        readonly lo?: number;
-        readonly hi?: number;
-    };
-}
-interface Input {
-    readonly place: string;
-    readonly text?: string;
-    readonly held?: readonly (readonly [string, string])[];
-    readonly region?: string;
-}
-/** The host end of the contract, beside the command that started this process: a module runs in a process of its own. */
-export declare const hostOf: () => string;
-/**
- * A reader runs as a process of its own, started by the runtime from the module its lock names, in the root its places
- * are named from: the instrument loads no capsule into itself. It is asked through the one contract, each place with
- * the file it is handed or alone when it reads the place by running it, as the region it was matched for when its
- * capsule reads with several, and answers one list of claims per place.
- */
-export declare function runReader(module: string, root: string, inputs: readonly Input[], limits?: ReaderLifetime): readonly (readonly Row[])[];
-export {};

package/dist/observe/runner.d.ts

@@ -1,20 +0,0 @@
-export declare const ownRoot: () => string;
-/** A published instrument carries its own content store even before any ledger
- * exists. Public-lock recognition grants no authority; legacy signed delivery
- * trees retain their historical colocated-ledger or sibling-store layout. */
-export declare function instrumentStoreAt(root: string): string;
-export declare const ownStore: () => string;
-export declare const ownLock: () => readonly string[];
-export declare const sourceOf: () => string;
-export declare function processOf(name: string, folder?: string): string;
-/**
- * A reader's code is what the bundler takes of it: its module and every file that module imports, wherever it lies, as
- * one blob of the tree's store named by the digest of its bytes. The files the bundler read, at the stamps they had, key
- * the blob, so it is built again only when one of them moved, and a helper a step above the module is one of them.
- */
-export declare function bundleOf(module: string): string | undefined;
-/** A reader run by a blob is a blob itself: its bundle, with everything it imports but the compiler. */
-export declare function readerOf(module: string): {
-    readonly path: string;
-    readonly flags: readonly string[];
-};

package/dist/render/capsule.d.ts

@@ -1,24 +0,0 @@
-import type { PlaceFold } from '../cli/place.ts';
-type Asking = {
-    readonly name: string;
-    readonly at: number;
-};
-type Viewed = {
-    readonly asking: readonly Asking[];
-    readonly shape: string;
-};
-export declare const capsuleRegions: (fold: PlaceFold, asking: readonly Asking[], shape?: string) => ReadonlyMap<string, readonly string[]>;
-/**
- * A region this instrument does not render is rendered by a capsule: one the place uses by the digest of its lock and
- * its bytes, or else one the instrument carries. What the views of one fold ask of each capsule is asked at once; a
- * region one capsule answered is not asked of another, and one it refused or never answered is named and asked of the
- * next only when no region was offered. A refusal from an offered region stops the request; it never selects another implementation.
- */
-export declare const capsuleViews: (fold: PlaceFold, views: readonly Viewed[]) => readonly ReadonlyMap<string, readonly string[]>[];
-type Answer = {
-    readonly lines: readonly string[];
-    readonly by: string;
-};
-/** What each capsule answered a view's regions with, the capsule by its digest, and whether the place's pin chose it. */
-export declare function capsuleAnswers(fold: PlaceFold, views: readonly Viewed[]): readonly ReadonlyMap<string, Answer>[];
-export {};

package/dist/render/field.d.ts

@@ -1,3 +0,0 @@
-import type { PlaceFold } from '../cli/place.ts';
-/** Host file-region readings, grouped by coordinate prefix. These statuses do not compute object encounters. */
-export declare function field(fold: PlaceFold, at: number): readonly string[];

package/dist/render/names.d.ts

@@ -1,3 +0,0 @@
-/** The regions bound renders itself, by name: a view that asks any other is answered by a capsule that declares it, or refused whole. */
-export declare const REGION_NAMES: readonly ["receipts", "help", "lines", "red", "forks", "programs", "why", "sign", "take", "history", "field", "evidence"];
-export type RegionName = (typeof REGION_NAMES)[number];

package/dist/render/open.d.ts

@@ -1,27 +0,0 @@
-export interface OpenCell {
-    readonly scope: string;
-    readonly ceiling: string;
-    readonly bits: number | null;
-    readonly freedom: string;
-    readonly states: readonly string[];
-    readonly origins: readonly string[];
-    readonly rank: number;
-    readonly cone: string;
-}
-/**
- * What is open, as cells, taken once when the tree is folded and read by the view rather than taken again at every
- * render. A line of the lock with more than one bit still free is a question this tree has not answered; a cell with
- * one legal state is applied and not open; a cell a reading has already answered is applied whatever its width; a
- * cell standing on one origin with a closer already named is asked and not open. A cell says of itself that it is a
- * decision: a ceiling in force is not a question because it is wide, and a lock with no decision in it is a lock with
- * nothing open, which the render says by saying nothing. What each state would be worth is rendered beside it, and a quantity this instrument cannot yet take is
- * rendered grey with the name of what would take it, never as a number it invented.
- */
-export declare function openCells(input: {
-    readonly store: string;
-    readonly standing: readonly string[];
-    readonly observed: readonly string[];
-    readonly grey: readonly string[];
-    readonly epoch: number;
-}): readonly OpenCell[];
-export declare const openCards: (open: readonly OpenCell[]) => readonly string[];

package/dist/render/page.d.ts

@@ -1,3 +0,0 @@
-import type { PlaceFold } from '../cli/place.ts';
-export declare const secondName: () => string;
-export declare const nameOf: (fold: Pick<PlaceFold, "standing" | "under">) => string;

package/dist/render/receipts.d.ts

@@ -1,3 +0,0 @@
-import type { PlaceFold } from '../cli/place.ts';
-/** Native receipts are a protocol projection of actual fold observations, not a domain renderer or an acceptance verdict. */
-export declare function receiptRegion(fold: PlaceFold, at: number): readonly string[];

package/dist/render/shape.d.ts

@@ -1,16 +0,0 @@
-import type { PlaceFold } from '../cli/place.ts';
-export declare function shapeLines(fold: PlaceFold): readonly string[];
-/**
- * What moved a verdict: the world under it, or a head that signed. A demand whose judgement came out differently than
- * the time before moved by observation unless its own line was re-signed, in which case the lock moved and not the
- * world; a verdict moved by a signature is not the world moving.
- */
-export declare function moved(fold: PlaceFold): {
-    readonly observation: number;
-    readonly signature: number;
-};
-/** The source coordinates of the tree no reader has reached: the number that falls when knowing advances. The walk never enters the store or a foreign directory, whose coordinates are never sources. */
-export declare function horizonOf(fold: PlaceFold): {
-    readonly unread: number;
-    readonly sources: number;
-};

package/dist/render/target.d.ts

@@ -1,18 +0,0 @@
-import type { Fork } from '../fold/claims.ts';
-/** TARGET is a render of the fold of the owner's ledger: a fork shows every signed line that stands, under a note. */
-export declare function renderTarget(ownerLines: readonly string[], today?: string, authority?: (line: string) => {
-    readonly kind: string;
-    readonly why?: string;
-}, receipts?: readonly {
-    readonly scope: string;
-    readonly moved: readonly string[];
-}[]): {
-    readonly text: string;
-    readonly standing: number;
-    readonly superseded: readonly string[];
-    readonly retracted: readonly string[];
-    readonly forks: readonly Fork[];
-    readonly grey: readonly string[];
-    readonly refused: readonly string[];
-    readonly vacuous: readonly string[];
-};

package/dist/render/view.d.ts

@@ -1,22 +0,0 @@
-import type { PlaceFold } from '../cli/place.ts';
-import type { View } from '../fold/views.ts';
-export declare const askWhy: (fold: PlaceFold, coord: string) => void;
-export declare const unrendered: (fold: PlaceFold, view: {
-    readonly regions: readonly {
-        readonly name: string;
-    }[];
-}) => readonly string[];
-export declare function render(fold: PlaceFold, regions: readonly {
-    readonly name: string;
-    readonly at: number;
-}[], shape?: string): string;
-export declare function prerender(fold: PlaceFold, views: readonly View[]): void;
-export declare function viewOf(fold: PlaceFold, view: View): string;
-export declare function renderedOf(fold: PlaceFold, view: {
-    readonly name: string;
-    readonly shape: string;
-    readonly regions: readonly {
-        readonly name: string;
-        readonly at: number;
-    }[];
-}): readonly string[];

package/dist/wasm/node-worker.d.ts

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

package/dist/wasm/object.d.ts

@@ -1,8 +0,0 @@
-import type { ObjectRecord, ObjectContext } from '@lapxo/topos/wire';
-import type { ObjectReading } from '../engine/index.ts';
-type Fields = Readonly<Record<string, string>>;
-/** Configuration is the caller's already authenticated, live standing; selection grants no authority. */
-export declare function usesWasmObject(configuration: readonly Fields[]): boolean;
-/** The installed instrument owns the asset/form closure; place input cannot choose executable bytes. */
-export declare function foldObjectsWithWasm(root: string, records: readonly ObjectRecord[], context: ObjectContext, configuration: readonly Fields[], signal?: AbortSignal): Promise<readonly ObjectReading[]>;
-export {};

package/dist/wasm/worker.d.ts

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