@lapxo/bound 0.2.0 → 0.2.1

package/dist/host/ports/signing.d.ts

@@ -1,31 +0,0 @@
-/** Contains only host-controlled diagnostics, never child output. */
-export declare class SigningFailure extends Error {
-}
-export interface SigningLot {
-    readonly bytes: readonly string[];
-    readonly keyId: string;
-    readonly algorithm: string;
-}
-export interface SignatureRecord {
-    readonly keyId: string;
-    readonly signature: string;
-}
-export interface SigningProtocol {
-    readonly request: (lot: SigningLot) => string;
-    readonly response: (records: readonly SignatureRecord[]) => string;
-    readonly reply: (text: string, lot: SigningLot) => readonly SignatureRecord[];
-}
-export type SigningMechanism = {
-    readonly kind: 'file';
-    readonly path: string;
-} | {
-    readonly kind: 'command';
-    readonly executable: string;
-    readonly args: readonly string[];
-};
-export interface SigningLimits {
-    readonly timeoutMs: number;
-    readonly responseBytes: number;
-}
-/** Host-approved mechanism only. Repository declarations do not authorize execution. */
-export declare function invokeSigner(lot: SigningLot, mechanism: SigningMechanism, protocol: SigningProtocol, limits: SigningLimits): Promise<readonly SignatureRecord[]>;

package/dist/host/ports/store.d.ts

@@ -1,2 +0,0 @@
-export declare function storeRoot(from: string): string;
-export declare const storeDirs: (store: string) => number;

package/dist/host/ports/transport.d.ts

@@ -1 +0,0 @@
-export declare function transportBytes(location: string, digest: string, lines: readonly string[]): Promise<Uint8Array>;

package/dist/host/process-lifetime.d.ts

@@ -1,11 +0,0 @@
-import type { ReaderLifetime } from '@lapxo/topos/wire';
-export interface ProcessResult {
-    readonly stdout: string;
-    readonly stdoutBytes?: string;
-    readonly stderr: string;
-    readonly status: number | null;
-    readonly signal: NodeJS.Signals | null;
-    readonly failure?: string;
-}
-/** A synchronous fold waits on a supervising host process; the supervisor owns cancellation of its child group. */
-export declare function boundedProcess(command: string, args: readonly string[], input: string, limits: ReaderLifetime, cwd?: string, env?: Readonly<Record<string, string>>): ProcessResult;

package/dist/host/provide.d.ts

@@ -1,48 +0,0 @@
-interface ResolveContext {
-    parentURL?: string;
-}
-interface ResolveResult {
-    url: string;
-}
-type NextResolve = (specifier: string, context: ResolveContext) => ResolveResult;
-/**
- * Resolve declared library bytes for this host. A library's shape may select an
- * archive coordinate; world selection remains the standing contract.
- */
-export declare function pinPlace(name: string): string;
-export declare function pinExport(name: string, sub: string): string;
-export declare function pinName(name: string): string;
-/** Node package resolution at a digest-laid library; exports remain authoritative. */
-export declare function resolvePinned(specifier: string, context: ResolveContext, nextResolve: NextResolve, pin: {
-    readonly at: string;
-    readonly pkg: string;
-    readonly json: string;
-    readonly exports: boolean;
-}): ResolveResult;
-/** Fixed execution selects libraries by the instrument's explicit local mount,
- * before opening any artifact. An alias or package-name guess grants nothing. */
-export declare function selectNativeDependencies(root: string, dependencies: readonly string[], manifest: string): readonly {
-    line: string;
-    library: {
-        readonly name: string;
-        readonly manifest: string;
-        readonly coordinate?: string;
-    };
-}[] | undefined;
-/** A declared artifact is not automatically an active Node library. This fixed
- * assertion reuses only the packages selected by the actual host boundary. */
-export declare function reuseNativeResolution(pins: readonly {
-    pkg: string;
-    at: string;
-}[]): boolean;
-/** Read one resolved archive's manifest; a selected fixed library cannot vanish
- * into the optional historical provider path when its archive is absent. */
-export declare function readProvidedPin(name: string, at: string, file: string, requiredName?: string): {
-    at: string;
-    pkg: string;
-    exports: boolean;
-    href: string;
-    json: string;
-} | undefined;
-export declare function provide(): void;
-export {};

package/dist/host/read-only.d.ts

@@ -1,3 +0,0 @@
-export declare const readOnly: () => boolean;
-export declare const withoutEffects: <T>(evaluate: () => T) => T;
-export declare function requireEffects(operation: string): void;

package/dist/host/reading-closures.d.ts

@@ -1,47 +0,0 @@
-import type { ReaderLifetime, ReaderReference } from '@lapxo/topos/wire';
-import type { Capsule } from './capsule.ts';
-import { snapshotAccess } from '@lapxo/topos/contract';
-import type { ReadingIdentityContext, Snapshot, ResponseContext } from '@lapxo/topos/contract';
-import type { ReadingExecution, ReadingReference } from './reading-context.ts';
-export interface CurrentReading {
-    readonly snapshot: Snapshot;
-    readonly kept: ResponseContext;
-    readonly current: ResponseContext;
-    readonly permission: Parameters<typeof snapshotAccess>[3];
-}
-type File = {
-    readonly place: string;
-    readonly text: string;
-};
-export declare const inputLines: (files: readonly File[]) => readonly string[];
-/** One portable native receipt carrier shared by file plans and native capsule batches. */
-export declare function portableReadingReceipt(scope: string, by: string, closure: string, output: string, hash: (text: string) => string, modern?: boolean, costs?: readonly string[]): readonly string[];
-/** The selected world owns input projection and reading. The host only verifies closures and keeps native count/bytes receipts. */
-export declare function readingClosures(options: {
-    root: string;
-    store: string;
-    reader: string;
-    speaker: string;
-    digest: (text: string) => string;
-    capsule: Capsule;
-    region: string;
-    projection: string;
-    readerReference?: ReaderReference;
-    lifetime?: ReaderLifetime;
-    allowsEmpty?: boolean;
-    context?: ReadingIdentityContext;
-    execution?: ReadingExecution;
-    current?: CurrentReading;
-    files: readonly File[];
-    livePlace?: () => readonly string[];
-    assertCurrent?: () => void;
-    emit?: (line: string) => void;
-}): {
-    lines: readonly string[];
-    read: number;
-    opened: number;
-    executed: number;
-};
-/** Verify the native reading carriers before a file seal may reuse them. These are semantic receipts, not file-region seals. */
-export declare function verifiedReadingReceipts(store: string, lines: readonly string[], digest: (text: string) => string, environment?: readonly ReadingReference[] | ((context: ReadingIdentityContext) => readonly ReadingReference[] | undefined), requireContext?: boolean): number | undefined;
-export {};

package/dist/host/reading-context.d.ts

@@ -1,29 +0,0 @@
-import type { ReadingIdentityContext } from '@lapxo/topos/contract';
-export type ReadingReference = readonly [string, string];
-export interface ReadingExecution {
-    readonly context: ReadingIdentityContext;
-    readonly env: Readonly<Record<string, string>>;
-    readonly cwd: string;
-    readonly flags: readonly string[];
-}
-interface Boundary {
-    readonly identity: string;
-    readonly execution?: ReadingExecution;
-}
-export declare const readingBoundary: () => Boundary | undefined;
-export declare function withReadingBoundary<T>(identity: string, execution: ReadingExecution | undefined, run: () => T): T;
-export declare function readingEnvironment(hash: (text: string) => string, env?: Readonly<Record<string, string | undefined>>, cwd?: string, flags?: readonly string[]): readonly ReadingReference[];
-export declare function readingProfile(lines: readonly string[], field: (line: string, name: string) => string): boolean;
-/** The caller supplies verified implementation and transitive references. This
- * constructor adds the process boundary that the host will actually hand over. */
-export declare function readingExecution(input: {
-    instrument: string;
-    implementation: string;
-    policy: string;
-    inputs: readonly ReadingReference[];
-}, hash: (text: string) => string, boundary?: {
-    env: Readonly<Record<string, string | undefined>>;
-    cwd: string;
-    flags: readonly string[];
-}): ReadingExecution;
-export {};

package/dist/host/reference.d.ts

@@ -1,6 +0,0 @@
-export declare function inspectReference(fragment: string, policy: readonly string[]): Promise<{
-    reference: import("./reference-profile.ts").StandingReference;
-    lines: readonly string[];
-    standing: string;
-    authentication: string;
-}>;

package/dist/host/release.d.ts

@@ -1,14 +0,0 @@
-export declare const laidAt: (store: string, digest: string) => string;
-/** A host artifact binding, not a measured ceiling or an object act. */
-export declare const isReleaseBinding: (line: string) => boolean;
-export declare const releasesOf: (lock: readonly string[]) => readonly string[];
-/**
- * What the host does before anything runs: each release the instrument's own lock names by digest is a snapshot of
- * lines and digests, kept by digest, and the place the line needs is a materialization of verified CAS bytes. Materialized files do not share writable inodes with the store. A blob is laid only when its bytes hash to the digest that names it. What stands laid is
- * said by resolvedOf: a line for each release whose blob hashes to its name and whose place, or the cas when its line
- * needs none, holds it.
- */
-export declare function layReleases(store: string, own: string, lock: readonly string[], contentStore?: string): number;
-export declare const resolvedOf: (store: string, own: string, lock: readonly string[], contentStore?: string) => readonly string[];
-/** A host loads verified release bytes from a runtime tree, never interprets a snapshot file as a directory. */
-export declare function runtimeTreeAt(store: string, own: string, digest: string, contentStore?: string, root?: string): string | undefined;

package/dist/host/root-clock-source.d.ts

@@ -1,85 +0,0 @@
-import { type PlaceReceipt, type ClockBudget } from '@lapxo/topos/core';
-import type { PlaceActBudget } from './ports/place-act.ts';
-export interface RootClockSourceSelection {
-    readonly selector: string;
-    readonly profileSelector: string;
-    readonly bootstrapCheckpoint: {
-        scope: string;
-        measure: string;
-    };
-    readonly resources: {
-        bytes: number;
-        lines: number;
-        places: number;
-        acts: number;
-    };
-    readonly inherited: {
-        clock: ClockBudget;
-        storage: PlaceActBudget;
-    };
-}
-export declare function rootClockSource(root: string, selected: RootClockSourceSelection): {
-    observation: Readonly<{
-        history: readonly string[];
-        anchor: import("@lapxo/topos/wire").Signer;
-        algorithms: readonly string[];
-    }>;
-    resources: Readonly<{
-        bytes: number;
-        lines: number;
-        places: number;
-        acts: number;
-    }>;
-    authority: (encoded: string) => {
-        anchor: import("@lapxo/topos/wire").Signer;
-        history: readonly string[];
-        checkpoint: string;
-    };
-    selection: import("./place-clock-selection.ts").HostClockSelection;
-    trust: import("./ports/place-act.ts").PlaceActTrust;
-};
-/** Source mapping is an explicit Root declaration; absence never means a zero
- * clock or an inferred cursor. Existing legacy callers do not request it. */
-export declare function declaredRootClockSource(root: string): {
-    observation: Readonly<{
-        history: readonly string[];
-        anchor: import("@lapxo/topos/wire").Signer;
-        algorithms: readonly string[];
-    }>;
-    resources: Readonly<{
-        bytes: number;
-        lines: number;
-        places: number;
-        acts: number;
-    }>;
-    authority: (encoded: string) => {
-        anchor: import("@lapxo/topos/wire").Signer;
-        history: readonly string[];
-        checkpoint: string;
-    };
-    selection: import("./place-clock-selection.ts").HostClockSelection;
-    trust: import("./ports/place-act.ts").PlaceActTrust;
-};
-export declare function hasRootClockSource(root: string): boolean;
-export interface PortablePlaceContext {
-    readonly identity: string;
-    readonly context: string;
-    readonly receipts: readonly PlaceReceipt[];
-    readonly authority: {
-        anchor: import('@lapxo/topos/wire').Signer;
-        history: readonly string[];
-        checkpoint: string;
-    };
-}
-/** Historical inspection ONLY. The expected acting Root anchor and resource
- * selection come from the consumer's selected place, never from this packet.
- * This function returns data and cannot construct a current command permit. */
-export declare function inspectPortablePlaceContexts(encoded: string, expectedAnchor: import('@lapxo/topos/wire').Signer, selected: RootClockSourceSelection): {
-    identity: string;
-    context: import("@lapxo/topos/core").PlaceAct;
-}[];
-/** Prospective configuration is checked as authenticated Root history, never
- * against a prose birth condition. Initial heads are explicit typed selections;
- * stored committed chains cannot disappear when a selection is activated or
- * replaced. Preview reads only; the real admission repeats under its Root lock. */
-export declare function assertProspectiveRootClockSelection(root: string, signed: readonly string[]): void;

package/dist/host/selected-capsules.d.ts

@@ -1,8 +0,0 @@
-import { capsuleAt } from './capsule.ts';
-import type { Capsule } from './capsule.ts';
-import type { ToposResolver } from './selected-topos.ts';
-/** Only explicit capsule offers request execution. Forms/classes/views do not need an executable alias. */
-export declare function selectedCapsules(pins: readonly string[], resolve?: typeof capsuleAt, select?: ToposResolver, host?: readonly string[]): readonly {
-    readonly capsule: Capsule;
-    readonly offer: string;
-}[];

package/dist/host/selected-topos.d.ts

@@ -1,24 +0,0 @@
-import type { StandingTopos } from '@lapxo/topos/standing';
-import { wireAt, fromLine } from '@lapxo/topos/wire';
-export interface SelectedTopos {
-    readonly digest: string;
-    readonly topos: StandingTopos;
-}
-export type ToposResolver = (digest: string) => StandingTopos;
-/** Local grammar is sufficient for locally declared records. Resolve selected
- * contracts only when a reader is missing; a local refusal remains a refusal. */
-export declare function admittedLine(line: string, local: readonly Readonly<Record<string, string>>[], epoch: number, pins: readonly string[], resolve?: ToposResolver): ReturnType<typeof fromLine>;
-/** Resolve content using the instrument wire's admitted digest algorithms. No transport interpretation. */
-export declare function toposAt(digest: string, store?: string): StandingTopos;
-export declare function contentAt(digest: string, store?: string): Uint8Array;
-/** The declared module runs from the store that supplied its verified bytes. No copy or live-checkout fallback. */
-export declare function contextModuleAt(digest: string, store?: string, dependencies?: readonly string[]): string;
-/** Selection verifies standing identity. Requested capabilities verify their artifact bytes separately. */
-export declare function selectedTopoi(pins: readonly string[], resolve?: ToposResolver): readonly SelectedTopos[];
-/** Read a declared wire list without copying a world's claims or executing its offers.
- * Independent declarations must agree; selection order cannot choose a contract.
- */
-export declare function selectedWireList(local: readonly string[], epoch: number, pins: readonly string[], list: string, resolve?: ToposResolver): readonly string[];
-/** Complete an admission snapshot from the selected standing. Local declarations
- * govern their own lists; independent selected contracts cannot choose by order. */
-export declare function selectedWireAt(local: readonly Readonly<Record<string, string>>[], epoch: number, pins: readonly string[], resolve?: ToposResolver): ReturnType<typeof wireAt>;

package/dist/host/signing.d.ts

@@ -1,3 +0,0 @@
-import type { SigningLot } from './ports/signing.ts';
-/** Resolve data before acquisition; all mechanisms use one wire protocol and verification path. */
-export declare function signerFor(lines: readonly string[], keyId: string, selected?: string, keyFile?: string): (lot: SigningLot) => Promise<readonly import("./ports/signing.ts").SignatureRecord[]>;

package/dist/host/source-content.d.ts

@@ -1,12 +0,0 @@
-export interface ContentPort {
-    readonly algorithms: ReadonlySet<string>;
-    readonly read: (digest: string) => Uint8Array | undefined;
-    readonly write: (digest: string, bytes: Uint8Array) => void;
-    readonly fetch: (url: string, digest?: string) => Promise<Uint8Array>;
-}
-/** Transport uses declared locations; only the requested digest admits bytes into the cache. */
-export declare function resolveSelectedContent(lines: readonly string[], port: ContentPort, requested: readonly string[]): Promise<readonly string[]>;
-/** Exact resource URLs; no repository checkout or inferred release. */
-export declare function resolveSources(standing: readonly string[], requested: readonly string[]): Promise<void>;
-/** A changed verified store is the only reason to retry. A repeated miss never loops or changes a named pin. */
-export declare function resolveRequested<T>(resolve: (digest: string) => Promise<void>, fold: () => Promise<T>): Promise<T>;

package/dist/host/timing.d.ts

@@ -1,2 +0,0 @@
-/** Record completed synchronous host work without changing its result or refusal. */
-export declare const timing: (spent: string[]) => <T>(what: string, fn: () => T) => T;

package/dist/host/walk.d.ts

@@ -1,6 +0,0 @@
-/** Verified foreign histories stay separate from the local authority and local epoch inputs. */
-export declare function foreignWalkLines(root: string): Promise<readonly string[]>;
-/** A declared origin exports its own signed history. Foreign packets are retained with their contexts, never re-signed as local history. */
-export declare function renderWalk(root: string, resolution: number | undefined, peer: readonly string[], key?: string, keyFile?: string, signer?: string): Promise<readonly string[]>;
-/** The SDK proves the foreign prefix; the host admits the pair at one publication point. */
-export declare function landWalk(root: string, lines: readonly string[], key?: string, keyFile?: string, signer?: string): Promise<readonly string[]>;

package/dist/judge/late.d.ts

@@ -1,7 +0,0 @@
-/**
- * A demand that landed after its coordinates. A take judges what moved, because it assumes the demand came first and the
- * tree after it; a demand that arrives second has nothing left to move — its cone is already in the ledger, every coordinate
- * of it vouched at a digest. Judging that is reading, not observing, so it is answered where it lands and no file is
- * touched to force it. A demand whose cone holds no vouched coordinate is not late, it is unlanded, and it waits for a take.
- */
-export declare function lateFacts(store: string, signed: readonly string[], answered: ReadonlySet<string>): readonly string[];

package/dist/judge/take.d.ts

@@ -1,59 +0,0 @@
-export interface Gate {
-    readonly kind: string;
-    readonly status: 'green' | 'red';
-    readonly ms: number;
-    readonly at: string;
-    readonly admitted: boolean;
-    readonly why: string;
-}
-interface Effect {
-    readonly kind: string;
-    readonly status: 'green' | 'red';
-    readonly ms: number;
-    readonly at: string;
-    readonly admitted: boolean;
-}
-/** E: the demand, its cone, the coordinates before and after by digest, and the effects that ran over the cone; an effect the ledger has never seen green answers for nothing yet: it runs, it lands, and it refuses nothing. */
-interface Envelope {
-    readonly scope: string;
-    readonly cone: readonly string[];
-    readonly before: Readonly<Record<string, string>>;
-    readonly after: Readonly<Record<string, string>>;
-    readonly effects: readonly Effect[];
-}
-type Verdict = {
-    readonly kind: 'fact';
-    readonly why: string;
-    readonly envelope: Envelope;
-    readonly digest: string;
-    readonly changed: readonly string[];
-} | {
-    readonly kind: 'refuse';
-    readonly why: string;
-    readonly envelope: Envelope;
-    readonly digest: string;
-    readonly changed: readonly string[];
-};
-export declare function judgeTake(input: {
-    readonly root: string;
-    readonly scope: string;
-    readonly value: string;
-    readonly locations: readonly string[];
-    readonly before: ReadonlyMap<string, string>;
-    readonly after: ReadonlyMap<string, string>;
-    readonly law?: readonly string[];
-    readonly template: string;
-    readonly shape?: string;
-    readonly restsOn?: string;
-    /** An unchanged cone may receive its first missing judgment; vouching bytes is not judgment. */
-    readonly unpaid?: boolean;
-    readonly witnessOf?: (coordinate: string) => string | undefined;
-}): Verdict & {
-    readonly notOwned: readonly string[];
-};
-/** A take that met its cone carries the gates its batch passed: their runs join its envelope, and its receipt is sealed with them. */
-export declare function sealed<V extends {
-    readonly envelope: Envelope;
-    readonly digest: string;
-}>(root: string, verdict: V, gates: readonly Gate[]): V;
-export {};

package/dist/judge/widening.d.ts

@@ -1 +0,0 @@
-export declare function widenedWithoutWitness(proposed: readonly string[], standing: readonly string[], isCeiling: (line: string) => boolean, witness: string): readonly string[];

package/dist/land/act.d.ts

@@ -1,30 +0,0 @@
-export declare function underTheRegions<T>(store: string, regions: readonly string[], what: string, act: () => T | Promise<T>): Promise<T>;
-/** Protect the root authority/policy read through child publication. This is
- * exclusion only: callers must authenticate contexts and compare prepared heads
- * while held. It creates no grant, clock advance, lease or automatic recovery. */
-export declare function underAuthorityRegions<T>(store: string, regions: readonly string[], what: string, act: () => T | Promise<T>): Promise<T>;
-/** Protect an authority snapshot without taking a child region. The acquisition
- * gate and temporary root marker exclude a root mutation while registering the
- * shared read; existing child acts continue independently. This is exclusion,
- * never authorization or a clock advance. */
-export declare function underRootAuthority<T>(store: string, what: string, act: () => T | Promise<T>): Promise<T>;
-export interface RootAuthorityProtection {
-    readonly store: string;
-    readonly lock: string;
-    readonly pid: number;
-    readonly token: string;
-}
-/** The fixed host may hand its child evidence of an actual held exclusion.
- * It is an operational envelope, not a grant, signer or receipt identity. */
-export declare function rootAuthorityProtection(store: string): RootAuthorityProtection;
-/** expectedStore and expectedParent come from the fixed host's inheritance
- * channel, never from world data. Matching a live lock proves exclusion only;
- * signature, coverage and current context still require verification. */
-export declare function assertRootAuthorityProtection(proof: RootAuthorityProtection, expectedStore: string, expectedParent: number): void;
-/** A child can publish independently, but the joined root projection and its
- * derived ledger appends have one writer. Authority protection already excludes
- * root mutations, so this lock needs no acquisition-gate upgrade. */
-export declare function underRootProjection<T>(store: string, what: string, act: () => T | Promise<T>): Promise<T>;
-export declare const holdRoot: (store: string, what: string) => Promise<void>;
-export declare function underTheLock<T>(store: string, what: string, act: () => T | Promise<T>): Promise<T>;
-export declare const holds: (store: string, region: string) => boolean;

package/dist/land/alias.d.ts

@@ -1,10 +0,0 @@
-/**
- * An alias is gone only when no pin will still name its digest. The pins are the root's uses lines and each world's own,
- * minus the pins this batch itself withdraws, plus the pins it adds. Checked before the trial, so a batch that would
- * orphan a pin lands nothing.
- */
-export declare function aliasPinned(root: string, signed: readonly string[]): readonly {
-    readonly scope: string;
-    readonly digest: string;
-    readonly by: readonly string[];
-}[];

package/dist/land/held.d.ts

@@ -1,7 +0,0 @@
-export interface Held {
-    readonly scope: string;
-    readonly bytes: number;
-    readonly at: string;
-}
-/** Bytes the store receipts name: a byte lives only while a standing line names it, and the receipts list what is there. */
-export declare const heldBytes: (_root: string, store: string, _standing: readonly string[]) => number;

package/dist/land/inert.d.ts

@@ -1,26 +0,0 @@
-/**
- * The ceilings of a batch that would stand unread: no reading meets them and no reading of the instrument's own
- * carries their measure. A batch that also signs a reader goes through whole, since what a reader reads is known only
- * once it runs, and so does a ceiling a gate of the same act reads, whose reading lands with it or refuses it.
- */
-export declare function inertIn(batch: readonly string[], input: {
-    readonly standing: readonly string[];
-    readonly ceiling: (line: string) => boolean;
-    readonly signsReader: boolean;
-    readonly observed: readonly string[];
-    readonly own: Readonly<Record<string, number>>;
-    readonly epoch: number;
-}): readonly string[];
-/** What each ceiling of a batch would bite, read off the summaries of the cone before anything lands. */
-export declare function rankedIn(batch: readonly string[], fold: {
-    readonly standing: readonly string[];
-    readonly observed: readonly string[];
-    readonly own: Readonly<Record<string, number>>;
-}): readonly string[];
-/** Every ceiling asked, at resolution one: what the fold reads for it, beside its bound, or unmeasured where no reading answers it. */
-export declare function readingsIn(ceilings: readonly string[], fold: {
-    readonly standing: readonly string[];
-    readonly observed: readonly string[];
-    readonly own: Readonly<Record<string, number>>;
-    readonly epoch: number;
-}): readonly string[];

package/dist/land/leaving.d.ts

@@ -1,14 +0,0 @@
-/**
- * A file goes from the tree through a line, never through a hand: its path withdrawn in the family the lock sources files
- * by is the only way a file goes, and the fold refuses it while a block still reads the file — what a run depends on is judged by the run's
- * own memo, which names every file each block read, and not by a search for the file's name in a test. A search misses
- * a name built in a loop; the memo does not. A test file goes with its own blocks, and is refused while one of them
- * is the only run of a vector or a sample, which it names.
- */
-export declare function coordinatesWithdrawn(root: string, store: string, signed: readonly string[], standing: readonly string[]): {
-    readonly taken: readonly string[];
-    readonly refused: readonly {
-        readonly path: string;
-        readonly by: string;
-    }[];
-};

package/dist/land/ledger.d.ts

@@ -1,33 +0,0 @@
-export declare function storeOf(root: string): string;
-/**
- * The store of a place: every name under it is read here and nowhere else, whoever needs a place asks for it by its
- * steps, and one append-only file per writer stands beside the bytes kept by digest — one per region for a writer
- * whose lines are about regions, so a fold opens only the regions it reaches. A file is read once per stamp, and a
- * ledger only grows: what it held is kept, and only the bytes appended since, from where it last ended a line, are read.
- */
-export declare function storeAt(store: string, ...steps: readonly string[]): string;
-export declare function writerFile(store: string, writer: string): string;
-export declare function ledgerLines(store: string, writer: string): readonly string[];
-export declare function shardFile(store: string, writer: string, region: string): string;
-export declare const shardLines: (store: string, writer: string, region: string) => readonly string[];
-export declare function ledgerWriters(store: string): readonly string[];
-/** One synchronous root-history read, not a retained authority snapshot.
- * Preserve writer order and each writer's legacy-before-committed ordering.
- * Every call rereads the complete committed inventory exactly once. */
-export declare function rootLedgerLines(store: string): readonly string[];
-export declare function landShard(store: string, writer: string, region: string, lines: readonly string[]): number;
-export declare function signedLines(store: string, writer: string): string[];
-export declare function blobAt(store: string, digest: string): string;
-/** A file replaced whole: the bytes land in a temp beside it and the name moves in one rename, so a killed write keeps the temp, never a torn file under the name a later read parses. */
-export declare function replaceWhole(at: string, bytes: Uint8Array | string): void;
-export declare const landBlob: (store: string, digest: string, bytes: Uint8Array) => string;
-export declare function holdStore(store: string, kind: 'blobs' | 'laid' | 'answers', name: string, bytes: number): void;
-export declare const memoAt: (store: string, key: string) => string;
-export declare function landMemo(store: string, key: string, bytes: Uint8Array): string;
-export declare const landEnvelope: (store: string, digest: string, bytes: string) => string;
-export declare function land(store: string, writer: string, lines: readonly string[]): {
-    readonly at: string;
-    readonly appended: number;
-};
-export declare function keptVerdict(store: string, tree: string, lot: string): unknown[] | undefined;
-export declare function keepVerdict(store: string, tree: string, lot: string, judged: readonly unknown[]): void;

package/dist/land/owned.d.ts

@@ -1,23 +0,0 @@
-export type Owned = {
-    readonly ledger: readonly string[];
-    readonly own: ReadonlyMap<string, readonly string[]>;
-    readonly nowhere: readonly string[];
-    readonly forked: readonly {
-        readonly place: string;
-        readonly key: string;
-    }[];
-};
-/**
- * A lot named with --place lands in those own locks and not the ledger: a lot never mixes. A line the ledger does not admit is a place's own when that place's own lock admits it: signed by a key the tree admits,
- * inside the window it held, inside its coverage of the place, the line's scope read as a region of the place. An own
- * lock speaks of its place without naming it, so a line whose scope names a place first is the ledger's alone, and the
- * same line can stand in many own locks: named places take every line they admit, and with none named a line lands in
- * the one own lock that admits it. The lines are told to their locks for the gates and land in them signed, beside what
- * the ledger takes. A line no lock admits, or one two locks would take and no place names, is admitted nowhere, and a
- * batch that holds one is refused whole: nothing is ever written into a lock bare. An own lot never forks a lock: lines
- * that would leave a place's lock with two standing claims where it had one are refused whole, so a lot for many places
- * lands the same lines at each, and lines meant for one place go in a lot of their own.
- */
-export declare function ownedOf(root: string, signed: readonly string[], admits: (line: string) => boolean, coverage: (by: string) => readonly string[], named?: readonly string[], placedAt?: (line: string) => readonly string[] | undefined): Owned;
-/** A place's own lock gains the lines a batch landed there, appended whole: a reader never meets half of it, and every line already there keeps its bytes as they were. */
-export declare function landOwned(root: string, place: string, lines: readonly string[], committed?: boolean): void;

package/dist/land/sign.d.ts

@@ -1,15 +0,0 @@
-import type { SigningLot, SignatureRecord } from '../host/ports/signing.ts';
-/** Prepare and verify a whole lot. No key material and no output/admission side effects. */
-export declare function signConsentLot(lines: readonly string[], stamp: {
-    readonly epoch?: number;
-    readonly by: string;
-    readonly algorithm: string;
-}, publicKey: string, admitted: readonly string[], invoke: (lot: SigningLot) => Promise<readonly SignatureRecord[]>): Promise<{
-    readonly kind: 'fact';
-    readonly lines: readonly string[];
-} | {
-    readonly kind: 'refuse';
-    readonly why: string;
-}>;
-export declare function verifiesOwnerLine(line: string, publicKeyPem: string, admitted: readonly string[]): boolean;
-export declare function verifiesFields(fields: Readonly<Record<string, string>>, publicKey: string, admitted: readonly string[]): boolean;

package/dist/land/standing-pin.d.ts

@@ -1,3 +0,0 @@
-/** A new world selection names standing bytes. Artifact aliases remain separate.
- * Admission reads laid content only; it never fetches or executes a provider. */
-export declare function admitStandingPins(root: string, lines: readonly string[], read?: (digest: string) => Uint8Array): void;

package/dist/land/vouched.d.ts

@@ -1,21 +0,0 @@
-import type { CoordinateRole } from '../fold/wire.ts';
-/** A location is a file or a directory; `x/*` names the directory `x/`. A deeper glob is not a location. */
-export declare function locationsOf(needs: string): {
-    readonly locations: readonly string[];
-    readonly refused: readonly string[];
-};
-/**
- * The source coordinates under one location, by digest. A path whose role is not source is never walked, so nothing under
- * it is read. A link is a coordinate whose bytes are its target; it is never followed.
- */
-export declare function coordinatesOf(root: string, location: string, roleOf: (coordinate: string) => CoordinateRole): Map<string, string>;
-/** The law a witness file says it answers for: its own `witness=<law>` line, or its `"witness"` field. */
-export declare function witnessOf(root: string, coordinate: string): string | undefined;
-export declare const vouching: (standing: readonly string[]) => string;
-export declare const sourced: (standing: readonly string[]) => string;
-export declare const sourceOf: (line: string) => string | undefined;
-export declare function inside(path: string, location: string): boolean;
-export declare function vouchedCoordinates(store: string): Map<string, string>;
-export declare function everLanded(store: string): ReadonlySet<string>;
-export declare function hasVouchedTree(store: string): boolean;
-export declare function landCoordinates(store: string, present: ReadonlyMap<string, string>, gone: readonly string[], at: string): number;