@lapxo/bound 0.2.4 → 0.2.5

package/dist/host/ports/local-act.d.ts

@@ -1,44 +0,0 @@
-import type { PublicationStorage } from './publication.ts';
-/** Prepared and verified by the selected Topos admission/result contract. */
-export interface LocalActBundle {
-    readonly records: string;
-    readonly receipt: string;
-    readonly placements?: readonly {
-        place: string;
-        records: string;
-    }[];
-}
-export type LocalActVerification = (identity: string, bundle: LocalActBundle) => boolean;
-export declare const actLines: (bytes: string) => readonly string[];
-/** Journal integrity is not authority. Signature/coverage checks remain the
- * same admission boundary; the hash algorithm here is the stored seal's named
- * algorithm, not a new selection of the place's wire.
- */
-export declare function intactLocalAct(identity: string, bundle: LocalActBundle): boolean;
-/** Internal integrity key only, not an act identity or a wire profile. */
-export declare function committedInventoryFingerprint(rows: readonly {
-    identity: string;
-    bundle: LocalActBundle;
-}[]): string;
-/** Committed segments are part of this ledger, not a second authority source. */
-export declare function committedLocalActs(store: string): readonly {
-    identity: string;
-    bundle: LocalActBundle;
-}[];
-/** Fixed host observation only: one synchronous, coherent committed inventory.
- * It supplies no authority, verifier or async lifetime. Each outer invocation
- * rereads exact bodies before entering; current authorization still runs inside.
- */
-export declare function withCommittedLocalActObservation<T>(store: string, body: () => T): T;
-/** A public result is available only as a verified committed pair.
- * No writer-tail guess, newest-result selection or implicit authority.
- */
-export declare function localActResult(store: string, identity: string, verify: LocalActVerification): LocalActBundle | undefined;
-/** One publication point for records and their native result. Re-delivery
- * reads the original pair without preparation, signing or a new local epoch.
- * The caller must also integrate this boundary into admission-history readers;
- * this storage port alone does not activate a grammar or land authority.
- */
-export declare function commitLocalAct(store: string, identity: string, regions: readonly string[], prepare: () => Promise<LocalActBundle>, verify: LocalActVerification, storage?: PublicationStorage, signal?: AbortSignal): Promise<LocalActBundle & {
-    readonly kind: 'landed' | 'once';
-}>;

package/dist/host/ports/place-act.d.ts

@@ -1,49 +0,0 @@
-import { type TrustedClockContract, type PlaceReceipt, type RootContext } from '@lapxo/topos/core';
-import { type PlaceActPersistence } from '../place-act-transaction.ts';
-import { type PublicationStorage } from './publication.ts';
-export interface PlaceActBudget {
-    readonly acts: number;
-    readonly bytes: number;
-}
-export interface PlaceActHead {
-    readonly place: string;
-    readonly identity: string;
-    readonly epoch: string;
-}
-export interface PlaceActSnapshot {
-    readonly root: RootContext;
-    readonly heads: readonly PlaceActHead[];
-}
-/** Fixed instrument construction, never supplied by world JSON. Historical
- * authentication permits inspection only; current() is read under Root guards. */
-export interface PlaceActTrust {
-    readonly contract: TrustedClockContract;
-    readonly initialHeads: readonly PlaceActHead[];
-    readonly current: () => PlaceActSnapshot;
-    readonly historical: (encoded: string) => TrustedClockContract;
-}
-export interface PlaceActBundle {
-    readonly context: string;
-    readonly receipts: readonly PlaceReceipt[];
-    readonly originals: readonly (readonly string[])[];
-}
-/** Historical result reads never produce a current authorization permit. */
-export declare function placeActResult(store: string, id: string, trust: Pick<PlaceActTrust, 'historical'>, limits: PlaceActBudget): PlaceActBundle | undefined;
-/** Each receiver chain advances independently. Initial heads are explicit,
- * authenticated host inputs, not inferred zero or legacy global epochs. */
-export declare function placeActHeads(store: string, initial: readonly PlaceActHead[], trust: Pick<PlaceActTrust, 'historical' | 'contract'>, limits: PlaceActBudget): readonly PlaceActHead[];
-/** Context, exact original bytes and complete signed receipts have one visibility
- * point. Real Root guard exclusion spans final authority/head comparison and
- * publication; this does not activate a CLI profile or reinterpret local-act@1. */
-/** Native persistence adapter. The transaction below is also the CLI path. */
-export declare function nativePlaceActPersistence(store: string, storage?: PublicationStorage): PlaceActPersistence;
-export declare function commitPlaceAct(store: string, encoded: string, receipts: readonly PlaceReceipt[], trust: PlaceActTrust, limits: PlaceActBudget, storage?: PublicationStorage): Promise<PlaceActBundle & {
-    readonly kind: "landed" | "once";
-    readonly identity: string;
-}>;
-/** Enumerates only committed, historically authenticated carriers. Namespace
- * projection is a caller's separate pure operation, never current permission. */
-export declare function committedPlaceActResults(store: string, trust: Pick<PlaceActTrust, 'historical'>, limits: PlaceActBudget): readonly {
-    identity: string;
-    bundle: PlaceActBundle;
-}[];

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

@@ -1,10 +0,0 @@
-export interface PublicationStorage {
-    publish(staged: string, committed: string): void;
-}
-export declare const nativePublicationStorage: PublicationStorage;
-/** Publish prepared bytes as one directory. No identity, grammar or authority
- * is inferred here. Readers address the committed name, never staging files.
- * A failure after rename is not evidence of rollback: the caller must retain
- * the uncertainty and allow a verified read of the committed name.
- */
-export declare function publishBundle(committed: string, files: Readonly<Record<string, string>>, storage?: PublicationStorage): void;

package/dist/host/reference-export.d.ts

@@ -1,33 +0,0 @@
-import type { SigningPort } from '../engine/ports.ts';
-export { BoundRefusal as ReferenceExportRefusal } from './refusals.ts';
-/** Signs a public snapshot proof; never lands, refreshes evidence or changes the Root. */
-export declare function exportAuthenticatedReference(root: string, source: string, options?: {
-    readonly key?: string;
-    readonly keyFile?: string;
-    readonly signer?: string;
-    readonly hostSigner?: {
-        readonly name: string;
-        readonly sign: SigningPort;
-    };
-}): Promise<{
-    profile: string;
-    reference: string;
-    carrier: string;
-    context: {
-        snapshot: string;
-        profile: string;
-        semanticIdentity: string;
-        epoch: number;
-        proofScope: string;
-        policy: string;
-        formImplementation: string;
-        signers: readonly import("@lapxo/topos/wire").Signer[];
-        algorithms: readonly string[];
-        contracts: {
-            refusals: string;
-            standing: string;
-        };
-        maxBytes: number;
-        maxRecords: number;
-    };
-}>;

package/dist/host/reference-native.d.ts

@@ -1,30 +0,0 @@
-import { type ContentReadPort } from '../engine/ports.ts';
-export declare function authenticatedReferenceSelected(standing: readonly string[]): boolean;
-/** One context preparation shared by native export and native inspection. */
-export declare function prepareNativeReference(root: string): Promise<{
-    policy: string;
-    formImplementation: string;
-    records: readonly import("@lapxo/topos/wire").ObjectRecord[];
-    context: import("@lapxo/topos/wire").ObjectContext;
-    configuration: Readonly<Record<string, string>>[];
-}>;
-export declare function openAuthenticatedReference(root: string, fragment: string, options?: {
-    readonly signal?: AbortSignal;
-    readonly content?: {
-        readonly name: string;
-        readonly read: ContentReadPort;
-    };
-}): Promise<{
-    backend: string;
-    readings: readonly import("../engine/object.ts").ObjectReading[];
-    contracts?: {
-        refusals: string;
-        standing: string;
-    } | undefined;
-    reference: import("./reference-profile.ts").StandingReference;
-    records: readonly import("@lapxo/topos/wire").ObjectRecord[];
-    semanticIdentity: string;
-    authorityContextIdentity: string;
-    semanticStanding: string;
-    originalRecords: readonly string[];
-}>;

package/dist/host/reference-profile.d.ts

@@ -1,23 +0,0 @@
-/** reference-profile@1: platform URL parsing, no authority or transport effects. */
-export interface StandingReference {
-    readonly class: 'standing';
-    readonly algorithm: 'sha256';
-    readonly digest: string;
-    readonly blob: string;
-    readonly source: string;
-}
-interface InspectionPort {
-    readonly maxBytes: number;
-    readonly readSemanticStanding: (bytes: string) => readonly string[];
-    readonly semanticStandingBytes: (lines: readonly string[]) => string;
-    readonly digestBytes: (bytes: Uint8Array) => string;
-}
-export declare function encodeReference(reference: StandingReference): string;
-export declare function decodeReference(fragment: string): StandingReference;
-export declare function inspectReferenceBytes(reference: StandingReference, bytes: Uint8Array, { maxBytes, readSemanticStanding, semanticStandingBytes, digestBytes }: InspectionPort): {
-    reference: StandingReference;
-    lines: readonly string[];
-    standing: string;
-    authentication: string;
-};
-export {};

package/dist/host/refusals.d.ts

@@ -1,14 +0,0 @@
-export interface RefusalEntry {
-    readonly code: string;
-    readonly category: string;
-    readonly meaning: string;
-    readonly next: string;
-}
-/** Stable code assigned at the cause. Details are diagnostic, never parsed as policy. */
-export declare class BoundRefusal extends Error {
-    readonly code: string;
-    constructor(code: string, diagnostic: string);
-}
-/** Pure machine contract reader. A catalog is data, never an authority grant. */
-export declare function readRefusalCatalog(text: string): readonly RefusalEntry[];
-export declare function describeRefusal(error: BoundRefusal, catalog: readonly RefusalEntry[]): RefusalEntry;

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

@@ -1,86 +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 rootClockSelectionOf(live: readonly string[], anchor: import('@lapxo/topos/wire').Signer): RootClockSourceSelection;
-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;