@lapxo/bound 0.1.8 → 0.2.0

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

@@ -0,0 +1,46 @@
+import { type TrustedClockContract, type PlaceReceipt, type RootContext } from '@lapxo/topos/core';
+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. */
+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/place-act.js

@@ -0,0 +1,169 @@
+import { existsSync, readdirSync, statSync, openSync, fstatSync, readSync, closeSync } from 'node:fs';
+import { join } from 'node:path';
+import { readPlaceActContext, verifyPlaceActContext, placeActReceiptsOf } from '@lapxo/topos/core';
+import { underAuthorityRegions, underTheRegions, underRootProjection } from "../../land/act.js";
+import { requireEffects } from "../read-only.js";
+import { publishBundle, nativePublicationStorage } from "./publication.js";
+const fail = (why) => { throw Error('REFUSE·place act ' + why); };
+const clock = (n) => { if (!/^(0|[1-9][0-9]*)$/.test(n) || !Number.isSafeInteger(Number(n)))
+    fail('unknown receiver clock'); return Number(n); };
+const rootBytes = (r) => JSON.stringify([r.namespace, r.snapshot, r.epoch, r.prefix, r.head, r.policies]);
+const budget = (b) => { if (!b || !Number.isSafeInteger(b.acts) || b.acts < 1 || !Number.isSafeInteger(b.bytes) || b.bytes < 1)
+    fail('missing storage budget'); };
+const base = (store) => join(store, 'ledger', 'place-acts');
+const at = (store, id) => { if (!id || id.includes('\0'))
+    fail('missing identity'); return join(base(store), 'committed-' + encodeURIComponent(id)); };
+function storedInventory(store, b) {
+    budget(b);
+    if (!existsSync(base(store)))
+        return { names: [], bytes: 0 };
+    const names = readdirSync(base(store)).filter(n => n.startsWith('committed-'));
+    if (names.length > b.acts)
+        fail('stored act budget');
+    let bytes = 0;
+    for (const name of names)
+        for (const member of ['context.json', 'receipts.json', 'originals.json']) {
+            const stat = statSync(join(base(store), name, member));
+            if (!stat.isFile() || (bytes += stat.size) > b.bytes)
+                fail('stored aggregate byte budget');
+        }
+    return { names, bytes };
+}
+function readBundle(path, b) {
+    budget(b);
+    let bytes = 0;
+    const read = (name) => {
+        const fd = openSync(join(path, name), 'r');
+        try {
+            const size = fstatSync(fd);
+            if (!size.isFile() || size.size > b.bytes - bytes)
+                fail('stored byte budget');
+            const data = Buffer.alloc(size.size);
+            let read = 0;
+            while (read < data.length) {
+                const count = readSync(fd, data, read, data.length - read, null);
+                if (!count)
+                    fail('stored member changed while reading');
+                read += count;
+            }
+            if (readSync(fd, Buffer.alloc(1), 0, 1, null) !== 0)
+                fail('stored member changed while reading');
+            bytes += read;
+            return new TextDecoder('utf-8', { fatal: true }).decode(data);
+        }
+        finally {
+            closeSync(fd);
+        }
+    };
+    try {
+        const context = read('context.json'), receipts = JSON.parse(read('receipts.json')), originals = JSON.parse(read('originals.json'));
+        return { context, receipts, originals };
+    }
+    catch (e) {
+        if (e instanceof Error && e.message.startsWith('REFUSE·'))
+            throw e;
+        return fail('committed bundle unreadable');
+    }
+}
+function authenticated(bundle, id, contract) {
+    const result = placeActReceiptsOf(bundle.context, bundle.receipts, contract), decoded = readPlaceActContext(bundle.context, contract.budget);
+    if (result.identity !== id || JSON.stringify(bundle.originals) !== JSON.stringify(decoded.places.map(p => p.records)))
+        fail('stored original/context identity mismatch');
+    return decoded;
+}
+/** Historical result reads never produce a current authorization permit. */
+export function placeActResult(store, id, trust, limits) {
+    const path = at(store, id);
+    if (!existsSync(path))
+        return undefined;
+    const bundle = readBundle(path, limits);
+    authenticated(bundle, id, trust.historical(bundle.context));
+    return bundle;
+}
+/** Each receiver chain advances independently. Initial heads are explicit,
+ * authenticated host inputs, not inferred zero or legacy global epochs. */
+export function placeActHeads(store, initial, trust, limits) {
+    budget(limits);
+    if (!initial.length || new Set(initial.map(h => h.place)).size !== initial.length)
+        fail('missing/ambiguous initial heads');
+    const heads = new Map(initial.map(h => { clock(h.epoch); if (!h.identity)
+        fail('missing initial head'); return [h.place, { ...h }]; }));
+    if (!existsSync(base(store)))
+        return [...heads.values()];
+    const { names } = storedInventory(store, limits);
+    const pending = names.map(name => { const id = decodeURIComponent(name.slice(10)), bundle = readBundle(join(base(store), name), limits); const context = authenticated(bundle, id, trust.historical(bundle.context)); if (context.root.namespace !== trust.contract.root.namespace)
+        fail('stored clock namespace mismatch'); return { id, context }; });
+    while (pending.length) {
+        const next = pending.findIndex(a => a.context.places.every(p => heads.get(p.place)?.identity === p.previous));
+        if (next < 0)
+            fail('receiver chain fork or missing predecessor');
+        const act = pending.splice(next, 1)[0];
+        for (const p of act.context.places) {
+            const prior = heads.get(p.place);
+            const epoch = clock(prior.epoch) + 1;
+            if (!Number.isSafeInteger(epoch) || clock(p.epoch) !== epoch)
+                fail('receiver chain clock mismatch');
+            heads.set(p.place, { place: p.place, identity: act.id, epoch: p.epoch });
+        }
+    }
+    return [...heads.values()];
+}
+/** 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. */
+export async function commitPlaceAct(store, encoded, receipts, trust, limits, storage = nativePublicationStorage) {
+    requireEffects('place act commitment');
+    budget(limits);
+    const decoded = readPlaceActContext(encoded, trust.contract.budget), id = trust.contract.digest(encoded);
+    const regions = decoded.places.map(p => { if (p.place === '.')
+        return ''; const parts = p.place.split('/'); if (parts.length < 2 || parts.pop() !== 'TARGET.bound' || parts.some(s => s === '' || s === '.' || s === '..'))
+        fail('unknown place namespace'); return parts.join('/'); });
+    const enter = regions.includes('') ? underTheRegions : underAuthorityRegions;
+    return enter(store, regions, 'place act', () => underRootProjection(store, 'place act publication', () => {
+        const prior = placeActResult(store, id, trust, limits);
+        if (prior) {
+            if (prior.context !== encoded)
+                fail('replay bytes differ');
+            // Replay authenticates the supplied evidence too. Historical authentication
+            // grants no current authority and leaves the committed result unchanged.
+            placeActReceiptsOf(encoded, receipts, trust.historical(encoded));
+            return { ...prior, identity: id, kind: 'once' };
+        }
+        const verified = verifyPlaceActContext(encoded, trust.contract);
+        placeActReceiptsOf(encoded, receipts, trust.contract);
+        const originals = decoded.places.map(p => p.records), files = { 'context.json': encoded, 'receipts.json': JSON.stringify(receipts) + '\n', 'originals.json': JSON.stringify(originals) + '\n' };
+        const inventory = storedInventory(store, limits);
+        if (inventory.bytes + Object.values(files).reduce((n, v) => n + Buffer.byteLength(v), 0) > limits.bytes)
+            fail('publication byte budget');
+        if (inventory.names.length >= limits.acts)
+            fail('publication act budget');
+        const current = trust.current();
+        if (rootBytes(current.root) !== rootBytes(verified.dependencies))
+            fail('authority changed before publication');
+        if (new Set(current.heads.map(h => h.place)).size !== current.heads.length)
+            fail('ambiguous receiver heads');
+        const storedHeads = placeActHeads(store, trust.initialHeads, trust, limits);
+        for (const p of decoded.places) {
+            const actual = storedHeads.find(h => h.place === p.place), selected = current.heads.find(h => h.place === p.place);
+            if (!actual || !selected || actual.identity !== selected.identity || actual.epoch !== selected.epoch)
+                fail('receiver snapshot is not committed head ' + p.place);
+        }
+        for (const p of decoded.places) {
+            const head = current.heads.find(h => h.place === p.place) ?? fail('missing receiver head ' + p.place);
+            if (head.identity !== p.previous)
+                fail('receiver head moved ' + p.place);
+            const next = clock(head.epoch) + 1;
+            if (!Number.isSafeInteger(next) || clock(p.epoch) !== next)
+                fail('receiver epoch not next ' + p.place);
+        }
+        publishBundle(at(store, id), files, storage);
+        return { context: encoded, receipts, originals, identity: id, kind: 'landed' };
+    }));
+}
+/** Enumerates only committed, historically authenticated carriers. Namespace
+ * projection is a caller's separate pure operation, never current permission. */
+export function committedPlaceActResults(store, trust, limits) {
+    const { names } = storedInventory(store, limits);
+    return names.map(name => { const identity = decodeURIComponent(name.slice(10)), bundle = placeActResult(store, identity, trust, limits); if (!bundle)
+        fail('committed carrier vanished'); return { identity, bundle: bundle }; });
+}

package/dist/host/process-lifetime.js

@@ -2,11 +2,16 @@ import { spawnSync } from 'node:child_process';
 import { processOf } from "../observe/runner.js";
 /** A synchronous fold waits on a supervising host process; the supervisor owns cancellation of its child group. */
 export function boundedProcess(command, args, input, limits, cwd, env) {
-    const run = spawnSync(process.execPath, [processOf('lifetime', 'host')], { input: JSON.stringify({ command, args, input, limits, cwd, env }), encoding: 'utf8', maxBuffer: limits.responseBytes * 12 + 4096 });
+    if (!Number.isSafeInteger(limits.timeoutMs) || limits.timeoutMs <= 0 || !Number.isSafeInteger(limits.responseBytes) || limits.responseBytes <= 0)
+        throw Error('REFUSE·reader invalid process limits');
+    // The same monotonic deadline covers handoff, input and execution. Starting a
+    // fresh timer after stdin closes would leave the handoff outside the policy.
+    const deadline = process.hrtime.bigint() + BigInt(limits.timeoutMs) * 1000000n;
+    const run = spawnSync(process.execPath, [processOf('lifetime', 'host'), String(deadline), String(limits.responseBytes)], { input: JSON.stringify({ command, args, input, limits, cwd, env }), encoding: 'utf8', maxBuffer: limits.responseBytes * 12 + 4096 });
     if (run.error || run.status !== 0)
-        throw Error(`REFUSE·reader lifetime supervisor ${run.error?.message ?? run.status}`);
+        throw Error(`REFUSE·reader lifetime supervisor ${run.error?.message ?? run.signal ?? run.status}`);
     const result = JSON.parse(run.stdout);
     if (result.failure)
-        throw Error(`REFUSE·reader ${result.failure} · status ${result.status ?? result.signal ?? 'cancelled'}`);
+        throw Error(`REFUSE·reader ${result.failure} · status ${result.status ?? result.signal ?? 'cancelled'}${result.stderr ? ' · child stderr: ' + result.stderr : ''}`);
     return result;
 }

package/dist/host/provide.d.ts

@@ -19,5 +19,30 @@ export declare function resolvePinned(specifier: string, context: ResolveContext
     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/provide.js

@@ -6,7 +6,9 @@ import { fieldOf } from "../fold/claims.js";
 import { observeText } from "../observe/files.js";
 import { ownLock, ownStore, ownRoot } from "../observe/runner.js";
 import { runtimeTreeAt } from "./release.js";
+import { ContentNeeded } from "./content-needed.js";
 import { theWord } from "../fold/wire.js";
+const findPackageJSON = nodeModule.findPackageJSON;
 const registerHooks = nodeModule.registerHooks;
 const taken = (exp) => (typeof exp === 'string' ? exp : exp && typeof exp === 'object' && 'default' in exp && typeof exp.default === 'string' ? exp.default : '');
 /**
@@ -53,29 +55,129 @@ export function resolvePinned(specifier, context, nextResolve, pin) {
  * blob's folder.
  */
 let hooked = false;
+function nativeResolution() {
+    const installed = Object.getOwnPropertyDescriptor(globalThis, Symbol.for('bound.native.resolution@1'));
+    if (!installed)
+        return undefined;
+    const capability = installed.value;
+    if (installed.configurable !== false || installed.writable !== false || !capability || !Object.isFrozen(capability) || capability.profile !== 'fixed-native-resolution@1' || !Array.isArray(capability.libraryNames) || !Object.isFrozen(capability.libraryNames) || capability.libraryNames.some(name => typeof name !== 'string') || !Array.isArray(capability.libraries) || !Object.isFrozen(capability.libraries) || capability.libraries.some(lib => !lib || !Object.isFrozen(lib) || typeof lib.name !== 'string' || typeof lib.manifest !== 'string') || typeof capability.assertPins !== 'function')
+        throw Error('REFUSE·pin fixed resolution capability invalid');
+    return capability;
+}
+/** Fixed execution selects libraries by the instrument's explicit local mount,
+ * before opening any artifact. An alias or package-name guess grants nothing. */
+export function selectNativeDependencies(root, dependencies, manifest) {
+    const capability = nativeResolution();
+    if (!capability)
+        return undefined;
+    if (dependencies.length && capability.libraries.some(library => typeof library.coordinate !== 'string' || !library.coordinate))
+        throw Error('REFUSE·pin fixed resolution logical library coordinate missing');
+    const selected = new Map(capability.libraries.map(library => [library.coordinate, library]));
+    return dependencies.flatMap(line => {
+        const mount = fieldOf(line, 'needs');
+        if (!mount)
+            return [];
+        const library = selected.get(mount.replace(/\/+$/, '') + '/' + manifest);
+        if (!library)
+            return [];
+        let actual;
+        try {
+            actual = realpathSync(join(root, mount, manifest));
+        }
+        catch {
+            throw Error('REFUSE·pin selected library mount absent ' + library.name);
+        }
+        if (actual !== library.manifest)
+            throw Error('REFUSE·pin selected library mount differs ' + library.name);
+        return [{ line, library }];
+    });
+}
+/** A declared artifact is not automatically an active Node library. This fixed
+ * assertion reuses only the packages selected by the actual host boundary. */
+export function reuseNativeResolution(pins) {
+    const capability = nativeResolution();
+    if (!capability)
+        return false;
+    const selected = new Set(capability.libraryNames);
+    // The fixed preload owns this closed assertion. Package names select which
+    // declared pins participate; exact manifests and member bytes still decide.
+    capability.assertPins(pins.filter(pin => selected.has(pin.pkg)).map(pin => ({ name: pin.pkg, at: pin.at })));
+    return true;
+}
+/** Read one resolved archive's manifest; a selected fixed library cannot vanish
+ * into the optional historical provider path when its archive is absent. */
+export function readProvidedPin(name, at, file, requiredName) {
+    if (!at) {
+        if (requiredName !== undefined)
+            throw Error('REFUSE·pin fixed resolution requires declared library ' + name);
+        return undefined;
+    }
+    const manifest = JSON.parse(observeText(join(at, file)) ?? '{}'), pkg = typeof manifest.name === 'string' ? manifest.name : '';
+    if (requiredName !== undefined && pkg !== requiredName)
+        throw Error('REFUSE·pin fixed resolution library name differs ' + name);
+    return pkg ? { at, pkg, exports: Object.prototype.hasOwnProperty.call(manifest, 'exports'), href: pathToFileURL(at).href, json: pathToFileURL(join(at, file)).href } : undefined;
+}
 export function provide() {
     if (hooked)
         return;
-    hooked = true;
-    const pins = ownLock()
-        .filter((line) => fieldOf(line, 'scope').startsWith('dep/') && fieldOf(line, 'role') === 'reads')
-        .flatMap((line) => {
-        const name = fieldOf(line, 'scope').slice('dep/'.length);
-        const at = pinPlace(name);
-        const pkg = pinName(name);
-        const file = manifestOf();
-        const manifest = JSON.parse(observeText(join(at, file)) ?? '{}');
-        return at && pkg ? [{ at, pkg, exports: Object.prototype.hasOwnProperty.call(manifest, 'exports'), href: pathToFileURL(at).href, json: pathToFileURL(join(at, file)).href }] : [];
+    const dependencies = ownLock().filter((line) => fieldOf(line, 'scope').startsWith('dep/') && fieldOf(line, 'role') === 'reads');
+    const file = manifestOf(), selected = selectNativeDependencies(ownRoot(), dependencies, file);
+    const load = (line, requiredName) => {
+        const name = fieldOf(line, 'scope').slice('dep/'.length), at = pinPlace(name);
+        if (!at)
+            throw new ContentNeeded(fieldOf(line, 'value'), 'REFUSE·pin declared library unavailable ' + name);
+        const pin = readProvidedPin(name, at, file, requiredName);
+        if (!pin)
+            throw Error('REFUSE·pin declared library unavailable ' + name);
+        return pin;
+    };
+    if (selected !== undefined) {
+        reuseNativeResolution(selected.map(({ line, library }) => load(line, library.name)));
+        hooked = true;
+        return;
+    }
+    // A mount selects a library, but its manifest is only a routing hint until
+    // an import requests it. The selected archive alone supplies executable bytes.
+    const mounts = dependencies.filter(line => fieldOf(line, 'needs') !== '').map(line => {
+        const mount = join(ownRoot(), fieldOf(line, 'needs'));
+        const manifest = JSON.parse(observeText(join(mount, file)) ?? '{}');
+        return { line, mount, pkg: typeof manifest.name === 'string' ? manifest.name : '' };
     });
+    const verified = new Map();
     registerHooks({
         resolve(specifier, context, nextResolve) {
             if (specifier.startsWith('.') || specifier.startsWith('/') || specifier.includes(':'))
                 return nextResolve(specifier, context);
-            const parent = context.parentURL ?? '';
-            const pin = pins.find((one) => specifier === one.pkg || specifier.startsWith(`${one.pkg}/`));
-            if (pin === undefined || parent.startsWith(pin.href))
+            let selected = mounts.find(one => one.pkg && (specifier === one.pkg || specifier.startsWith(one.pkg + '/')));
+            if (!selected) {
+                // Identify the installed package before following its executable entry:
+                // a renamed manifest and an escaping entry cannot bypass the declared mount.
+                let manifest;
+                try {
+                    manifest = findPackageJSON(specifier, pathToFileURL(join(ownRoot(), file)).href);
+                }
+                catch { }
+                if (manifest)
+                    selected = mounts.find(one => {
+                        try {
+                            return realpathSync(join(one.mount, file)) === realpathSync(manifest);
+                        }
+                        catch {
+                            return false;
+                        }
+                    });
+            }
+            if (!selected)
                 return nextResolve(specifier, context);
+            let pin = verified.get(selected.line);
+            if (!pin) {
+                pin = load(selected.line);
+                verified.set(selected.line, pin);
+            }
+            if (specifier !== pin.pkg && !specifier.startsWith(pin.pkg + '/'))
+                throw Error('REFUSE·pin selected library name differs');
             return resolvePinned(specifier, context, nextResolve, pin);
         },
     });
+    hooked = true;
 }

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

@@ -1,10 +1,21 @@
 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;
@@ -18,7 +29,12 @@ export declare function readingClosures(options: {
     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[];
@@ -27,5 +43,5 @@ export declare function readingClosures(options: {
     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): number | undefined;
+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 {};