@relayflows/sdk 2.0.28 → 2.0.30

package/src/bundle-extensions.ts

@@ -5,7 +5,7 @@ import { safePath, sha256 } from './bundle.js';
 import { findPluginProject } from './plugin-loader.js';
 import { parsePluginLock, readPluginLock, reconcileDeclaredExtensions, type PluginLock } from './plugin-lock.js';
 import { PluginError } from './plugin-manifest.js';
-import { pluginStoreDirectory, readStoredPluginFiles, verifyStoredPlugin } from './plugin-store.js';
+import { pluginStoreDirectory, readStoredPluginFiles } from './plugin-store.js';
 
 const EMPTY_LOCK: PluginLock = Object.freeze({ version: 2, plugins: Object.freeze([]) });
 
@@ -50,10 +50,11 @@ export async function verifyBundlePluginLock(bundle: string): Promise<void> {
       throw new Error(`lockfile.json: plugin name ${entry.name} is not a safe path component`);
     }
     const directory = join(bundle, 'plugins', entry.name);
-    await verifyStoredPlugin(directory, entry.digest);
-    let pluginManifest: Buffer;
-    try { pluginManifest = await readFile(join(directory, 'flows-plugin.json')); }
-    catch { throw new Error(`lockfile.json: plugin ${entry.name} is missing plugins/${entry.name}/flows-plugin.json`); }
+    const stored = await readStoredPluginFiles(directory, entry.digest);
+    const pluginManifest = stored.find(file => file.path === 'flows-plugin.json')?.data;
+    if (pluginManifest === undefined) {
+      throw new Error(`lockfile.json: plugin ${entry.name} is missing plugins/${entry.name}/flows-plugin.json`);
+    }
     if (sha256(pluginManifest) !== entry.manifestSha256) {
       throw new Error(`lockfile.json: plugin ${entry.name} flows-plugin.json does not match the lockfile manifest hash`);
     }

package/src/bundle.ts

@@ -2,6 +2,27 @@ import { createHash, createPrivateKey, createPublicKey, randomBytes, sign, verif
 import { lstat, mkdir, mkdtemp, readFile, readdir, rename, rm, writeFile } from 'node:fs/promises';
 import { basename, dirname, join, resolve } from 'node:path';
 import { canonicalize } from './canonical.js';
+import { appendIntrinsicArray } from './intrinsic-array.js';
+
+type Hash = ReturnType<typeof createHash>;
+const CREATE_HASH = createHash;
+const HASH_UPDATE = Function.prototype.call.bind(CREATE_HASH('sha256').update) as (
+  hash: Hash,
+  data: Uint8Array | string,
+) => Hash;
+const HASH_DIGEST = Function.prototype.call.bind(CREATE_HASH('sha256').digest) as (
+  hash: Hash,
+  encoding: 'hex',
+) => string;
+const STRING_INCLUDES = Function.prototype.call.bind(String.prototype.includes) as (
+  value: string, search: string,
+) => boolean;
+const STRING_SPLIT = Function.prototype.call.bind(String.prototype.split) as (
+  value: string, separator: string,
+) => string[];
+const TYPED_ARRAY_LENGTH = Function.prototype.call.bind(
+  Object.getOwnPropertyDescriptor(Object.getPrototypeOf(Uint8Array.prototype) as object, 'length')!.get!,
+) as (value: Uint8Array) => number;
 
 export interface BundleEntry { path: string; sha256: string; bytes: number }
 export interface BundleFile { path: string; data: Uint8Array | string; executable?: boolean }
@@ -15,14 +36,21 @@ export interface BundleOptions {
 }
 
 export function sha256(data: Uint8Array | string): string {
-  return createHash('sha256').update(data).digest('hex');
+  const hash = CREATE_HASH('sha256');
+  HASH_UPDATE(hash, data);
+  return HASH_DIGEST(hash, 'hex');
 }
 
 /** A bundle-relative path: no empty, `.`, or `..` component, no backslash, NUL, or drive colon. */
 export function safePath(path: string): boolean {
-  return path.length > 0 && !path.includes('\\') && !path.includes('\0')
-    && path.split('/').every(part => part !== '' && part !== '.' && part !== '..')
-    && !path.includes(':');
+  if (path.length === 0 || STRING_INCLUDES(path, '\\') || STRING_INCLUDES(path, '\0')
+    || STRING_INCLUDES(path, ':')) return false;
+  const parts = STRING_SPLIT(path, '/');
+  for (let index = 0; index < parts.length; index += 1) {
+    const part = parts[index]!;
+    if (part === '' || part === '.' || part === '..') return false;
+  }
+  return true;
 }
 
 /**
@@ -31,9 +59,26 @@ export function safePath(path: string): boolean {
  * thing everywhere: the digest of `[{bytes,path,sha256}]`, sorted by path.
  */
 export function payloadManifest(files: readonly { path: string; data: Uint8Array }[]): string {
-  return canonicalize([...files]
-    .sort((a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0)
-    .map(file => ({ path: file.path, sha256: sha256(file.data), bytes: file.data.length })));
+  const sorted: { path: string; data: Uint8Array }[] = [];
+  for (let index = 0; index < files.length; index += 1) appendIntrinsicArray(sorted, files[index]!);
+  // Do not consult mutable Array prototype methods here. Authored base code
+  // executes in this process before hosted artifact staging, so a live
+  // sort/map lookup would let it substitute bytes or manifest records.
+  for (let index = 1; index < sorted.length; index += 1) {
+    const current = sorted[index]!;
+    let position = index;
+    while (position > 0 && sorted[position - 1]!.path > current.path) {
+      sorted[position] = sorted[position - 1]!;
+      position -= 1;
+    }
+    sorted[position] = current;
+  }
+  const entries: { path: string; sha256: string; bytes: number }[] = [];
+  for (let index = 0; index < sorted.length; index += 1) {
+    const file = sorted[index]!;
+    appendIntrinsicArray(entries, { path: file.path, sha256: sha256(file.data), bytes: TYPED_ARRAY_LENGTH(file.data) });
+  }
+  return canonicalize(entries);
 }
 
 /** Manifest and identity are envelopes, excluded to avoid circular hashing. */

package/src/canonical.ts

@@ -9,6 +9,15 @@
 
 import { createHash } from 'node:crypto';
 import { snapshotJsonValue, type JsonValue } from './json-value.js';
+import { appendIntrinsicArray } from './intrinsic-array.js';
+
+const ARRAY_IS_ARRAY = Array.isArray;
+const ARRAY_JOIN = Function.prototype.call.bind(Array.prototype.join) as (
+  array: readonly string[], separator?: string,
+) => string;
+const ARRAY_SORT = Function.prototype.call.bind(Array.prototype.sort) as <T>(array: T[]) => T[];
+const JSON_STRINGIFY = JSON.stringify;
+const OBJECT_KEYS = Object.keys;
 
 /**
  * Serialize a value as canonical JSON: object keys sorted recursively,
@@ -42,16 +51,21 @@ export function specHash(spec: unknown): string {
  */
 function serialize(value: JsonValue): string {
   if (value === null || typeof value !== 'object') {
-    return JSON.stringify(value);
+    return JSON_STRINGIFY(value);
   }
-  if (Array.isArray(value)) {
-    return '[' + value.map(serialize).join(',') + ']';
+  if (ARRAY_IS_ARRAY(value)) {
+    const items: string[] = [];
+    for (let index = 0; index < value.length; index += 1) appendIntrinsicArray(items, serialize(value[index]!));
+    return '[' + ARRAY_JOIN(items, ',') + ']';
   }
   const parts: string[] = [];
-  for (const key of Object.keys(value).sort()) {
+  const keys = OBJECT_KEYS(value);
+  ARRAY_SORT(keys);
+  for (let index = 0; index < keys.length; index += 1) {
+    const key = keys[index]!;
     const child = value[key];
     if (child === undefined) continue;
-    parts.push(JSON.stringify(key) + ':' + serialize(child));
+    appendIntrinsicArray(parts, JSON_STRINGIFY(key) + ':' + serialize(child));
   }
-  return '{' + parts.join(',') + '}';
+  return '{' + ARRAY_JOIN(parts, ',') + '}';
 }

package/src/cli/status.ts

@@ -9,6 +9,7 @@
 // sandbox, its listener) is Cloud's to answer, and this verb does not guess.
 
 import type { CliIo } from '../cli.js';
+import { AUTHORED_STEP_STREAM, foldAuthoredStepRecords, type AuthoredStepRecord } from '../authored-step-index.js';
 import { canonicalize } from '../canonical.js';
 import { DEFAULT_DATA_DIR } from '../daemon-connection.js';
 import { JournalReadError, walkJournal, type JournalEvent } from '../journal-client.js';
@@ -179,7 +180,14 @@ export async function runStatus(args: StatusArgs, io: CliIo, options: StatusOpti
 
   const presented = present(view, thisStep, tails, env);
   if (args.json) {
-    io.stdout(canonicalize({ v: 1, ...presented, partial: taken.partial }));
+    const authored = authoredSteps(taken.events, env);
+    io.stdout(canonicalize({
+      v: 1, ...presented,
+      // Additive: only an authored root journals this stream, so every other
+      // run's JSON is byte-for-byte what it was.
+      ...(authored.length === 0 ? {} : { authored_steps: authored }),
+      partial: taken.partial,
+    }));
   } else {
     for (const line of renderText(presented, taken.partial, args.tail !== undefined)) io.stdout(line);
   }
@@ -187,6 +195,47 @@ export async function runStatus(args: StatusArgs, io: CliIo, options: StatusOpti
   return taken.partial.length === 0 ? 0 : 1;
 }
 
+/** One authored step as the root's `authored-steps` index names it. */
+export interface PresentedAuthoredStep {
+  step: string;
+  run_id: string;
+  state: AuthoredStepRecord['state'];
+  completion_reason?: string;
+  kernel_step?: string;
+  label?: string;
+  after?: string[];
+  after_truncated?: true;
+}
+
+/**
+ * The authored root's step index, folded from the journal already in hand.
+ *
+ * An authored body's steps each run in their own child journal, so a child's
+ * view cannot say what the step is called or what it waited for; the root's
+ * `authored-steps` stream can, from the moment each child is admitted. It is
+ * the same fold `readAuthoredStepIndex` applies through the daemon, so the two
+ * readers cannot disagree. Identifiers are printed as-is, like every other id
+ * here; the label is author-chosen free text and is redacted like one.
+ */
+function authoredSteps(events: readonly JournalEvent[], env: NodeJS.ProcessEnv): PresentedAuthoredStep[] {
+  const messages: unknown[] = [];
+  for (const event of events) {
+    if (event.entry_type !== 'stream.appended') continue;
+    const payload = event.payload as { stream?: unknown; message?: unknown } | null;
+    if (payload?.stream === AUTHORED_STEP_STREAM) messages.push(payload.message);
+  }
+  return [...foldAuthoredStepRecords(messages).values()].map((record) => ({
+    step: record.step,
+    run_id: record.runId,
+    state: record.state,
+    ...(record.completionReason === undefined ? {} : { completion_reason: record.completionReason }),
+    ...(record.kernelStep === undefined ? {} : { kernel_step: record.kernelStep }),
+    ...(record.label === undefined ? {} : { label: redact(record.label, env) }),
+    ...(record.after === undefined ? {} : { after: [...record.after] }),
+    ...(record.afterTruncated === true ? { after_truncated: true as const } : {}),
+  }));
+}
+
 type PresentedStep = StepView & { tails: StepTails };
 type Presented = Omit<RunView, 'steps'> & { this_step: string | null; steps: PresentedStep[] };
 

package/src/flow-extension-compat.ts

@@ -1,20 +1,38 @@
-import { readFileSync } from 'node:fs';
+import packageManifest from '../package.json' with { type: 'json' };
 import type { FlowExtensionManifest } from './flow-extension-manifest.js';
 import { PluginError } from './plugin-manifest.js';
 import { satisfiesRange } from './semver-range.js';
 
+const OBJECT_FREEZE = Object.freeze;
+// This static import is resolved before module evaluation and embedded by the
+// standalone Bun build. It neither consults mutable fs exports after authored
+// code nor depends on import.meta.url naming a real package directory.
+const RUNTIME_VERSIONS = OBJECT_FREEZE({
+  sdk: packageManifest.version,
+  surface: packageManifest.dependencies['@relayflows/surface']!,
+});
+
 export interface RuntimeVersions { readonly sdk: string; readonly surface: string }
 
 /** The versions a plugin's `compat` is checked against: this SDK and the surface it pins. */
 export function runtimeVersions(): RuntimeVersions {
-  const pkg = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8')) as { version: string; dependencies: Record<string, string> };
-  return { sdk: pkg.version, surface: pkg.dependencies['@relayflows/surface']! };
+  return RUNTIME_VERSIONS;
 }
 
 /** `compat.surface` / `compat.sdk` against the runtime: a miss is a refusal, never a warning. */
 export function assertCompatible(manifest: FlowExtensionManifest, versions: RuntimeVersions): void {
-  for (const [what, range, actual] of [['surface', manifest.compat.surface, versions.surface], ['sdk', manifest.compat.sdk, versions.sdk]] as const) {
-    if (!satisfiesRange(actual, range)) throw new PluginError('plugin_incompatible', `${manifest.name} requires ${what} ${range}; this runtime has ${actual}.`);
+  assertRuntimeRange(manifest, 'surface', manifest.compat.surface, versions.surface);
+  assertRuntimeRange(manifest, 'sdk', manifest.compat.sdk, versions.sdk);
+}
+
+function assertRuntimeRange(
+  manifest: FlowExtensionManifest,
+  what: 'surface' | 'sdk',
+  range: string,
+  actual: string,
+): void {
+  if (!satisfiesRange(actual, range)) {
+    throw new PluginError('plugin_incompatible', `${manifest.name} requires ${what} ${range}; this runtime has ${actual}.`);
   }
 }
 
@@ -23,9 +41,16 @@ export function assertCompatible(manifest: FlowExtensionManifest, versions: Runt
  * optional: a base without it matches only `"*"`.
  */
 export function assertBaseCompatible(manifest: FlowExtensionManifest, base: { readonly name: string; readonly version?: string }): void {
-  const entry = manifest.compat.base.find(b => b.name === base.name);
+  let entry: FlowExtensionManifest['compat']['base'][number] | undefined;
+  for (let index = 0; index < manifest.compat.base.length; index += 1) {
+    if (manifest.compat.base[index]!.name === base.name) entry = manifest.compat.base[index];
+  }
   if (entry === undefined) {
-    throw new PluginError('plugin_incompatible', `${manifest.name} extends ${manifest.compat.base.map(b => b.name).join(', ')}, not "${base.name}".`);
+    let names = '';
+    for (let index = 0; index < manifest.compat.base.length; index += 1) {
+      names += `${index === 0 ? '' : ', '}${manifest.compat.base[index]!.name}`;
+    }
+    throw new PluginError('plugin_incompatible', `${manifest.name} extends ${names}, not "${base.name}".`);
   }
   if (base.version === undefined) {
     if (entry.version !== '*') throw new PluginError('plugin_incompatible', `${manifest.name} requires ${base.name} ${entry.version}, but the base flow declares no version; only "*" can be satisfied.`);

package/src/flow-extension-loader.ts

@@ -1,4 +1,3 @@
-import { readFileSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 import type { Ctx } from '@relayflows/surface';
 import type { AuthoredFlowDefinition, FlowHandle } from './authored-flow.js';
@@ -6,9 +5,22 @@ import { sha256 } from './bundle.js';
 import { assertBaseCompatible, assertCompatible, runtimeVersions, type RuntimeVersions } from './flow-extension-compat.js';
 import { validateFlowExtensionManifest, type FlowExtensionManifest } from './flow-extension-manifest.js';
 import { findPluginProject } from './plugin-loader.js';
+import { appendIntrinsicArray } from './intrinsic-array.js';
 import { reconcileDeclaredExtensions, type PluginLockEntry } from './plugin-lock.js';
 import { PluginError } from './plugin-manifest.js';
-import { pluginStoreDirectory, verifyStoredPlugin } from './plugin-store.js';
+import { pluginStoreDirectory, readStoredPluginFiles } from './plugin-store.js';
+
+const JSON_PARSE = JSON.parse;
+const ARRAY_IS_ARRAY = Array.isArray;
+const JSON_STRINGIFY = JSON.stringify;
+const OBJECT_FREEZE = Object.freeze;
+const REGEXP_TEST = Function.prototype.call.bind(RegExp.prototype.test) as (
+  regexp: RegExp, value: string,
+) => boolean;
+const STRING_SPLIT = Function.prototype.call.bind(String.prototype.split) as (
+  value: string,
+  separator: string | RegExp,
+) => string[];
 
 /**
  * Compose schema-2 flow extensions onto a base authored flow.
@@ -94,7 +106,7 @@ function subscriptionOf(handler: TriggerHandler): { provider: string; event: str
   if (trigger.kind !== 'webhook' || trigger.filter === undefined) return undefined;
   const { provider, type, payload } = trigger.filter as { provider?: unknown; type?: unknown; payload?: unknown };
   if (typeof provider !== 'string' || provider !== trigger.name || typeof type !== 'string') return undefined;
-  const action = typeof payload === 'object' && payload !== null && !Array.isArray(payload) ? (payload as { action?: unknown }).action : undefined;
+  const action = typeof payload === 'object' && payload !== null && !ARRAY_IS_ARRAY(payload) ? (payload as { action?: unknown }).action : undefined;
   if (action !== undefined && typeof action !== 'string') return undefined;
   return action === undefined ? { provider, event: type } : { provider, event: type, action };
 }
@@ -115,32 +127,41 @@ export type HostedExtensionDispatch = {
   readonly deliveryId: string;
 };
 
-type HostedEventIdentity = { readonly provider: string; readonly event: string; readonly action?: string };
+export type HostedEventIdentity = { readonly provider: string; readonly event: string; readonly action?: string };
 const DISPATCH_PROVIDER = /^[a-z0-9][a-z0-9-]{0,63}$/;
 const DISPATCH_EVENT = /^[A-Za-z_][A-Za-z0-9_]*$/;
 const DISPATCH_DELIVERY = /^[A-Za-z0-9_.:-]{1,200}$/;
 
 function hostedEventIdentity(dispatch: unknown): HostedEventIdentity {
-  if (typeof dispatch !== 'object' || dispatch === null || Array.isArray(dispatch)) {
+  if (typeof dispatch !== 'object' || dispatch === null || ARRAY_IS_ARRAY(dispatch)) {
     throw new PluginError('plugin_event_unroutable', 'Hosted extension dispatch authority is malformed.');
   }
   const { provenance, provider, eventType, deliveryId } = dispatch as Partial<HostedExtensionDispatch>;
   if ((dispatch as Partial<HostedExtensionDispatch>)[HOSTED_EXTENSION_DISPATCH_AUTHORITY] !== true
     || provenance !== 'integration-watch'
-    || typeof provider !== 'string' || !DISPATCH_PROVIDER.test(provider)
-    || typeof deliveryId !== 'string' || !DISPATCH_DELIVERY.test(deliveryId)
+    || typeof provider !== 'string' || !REGEXP_TEST(DISPATCH_PROVIDER, provider)
+    || typeof deliveryId !== 'string' || !REGEXP_TEST(DISPATCH_DELIVERY, deliveryId)
     || typeof eventType !== 'string') {
     throw new PluginError('plugin_event_unroutable', 'Hosted extension dispatch authority is malformed.');
   }
-  const parts = eventType.split('.');
-  if ((parts.length !== 1 && parts.length !== 2) || parts.some(part => !DISPATCH_EVENT.test(part))) {
-    throw new PluginError('plugin_event_unroutable', `Hosted extension event ${JSON.stringify(eventType)} is malformed.`);
+  const parts = STRING_SPLIT(eventType, '.');
+  let valid = parts.length === 1 || parts.length === 2;
+  for (let index = 0; valid && index < parts.length; index += 1) {
+    valid = REGEXP_TEST(DISPATCH_EVENT, parts[index]!);
+  }
+  if (!valid) {
+    throw new PluginError('plugin_event_unroutable', `Hosted extension event ${JSON_STRINGIFY(eventType)} is malformed.`);
   }
   return parts.length === 1
     ? { provider, event: parts[0]! }
     : { provider, event: parts[0]!, action: parts[1]! };
 }
 
+/** Validate and project branded host authority without making it serializable. */
+export function hostedExtensionDispatchIdentity(dispatch: unknown): HostedEventIdentity {
+  return OBJECT_FREEZE(hostedEventIdentity(dispatch));
+}
+
 /**
  * Brand metadata only after the host has authenticated the integration
  * delivery. The symbol is deliberately not serializable, so copying a direct
@@ -149,7 +170,7 @@ function hostedEventIdentity(dispatch: unknown): HostedEventIdentity {
 export function hostedExtensionDispatchFromVerifiedDelivery(
   delivery: Omit<HostedExtensionDispatch, typeof HOSTED_EXTENSION_DISPATCH_AUTHORITY | 'provenance'>,
 ): HostedExtensionDispatch {
-  const dispatch = Object.freeze({
+  const dispatch = OBJECT_FREEZE({
     [HOSTED_EXTENSION_DISPATCH_AUTHORITY]: true as const,
     provenance: 'integration-watch' as const,
     ...delivery,
@@ -171,16 +192,29 @@ export function extensionHandlerForHostedDispatch(
 ): { readonly extension: Pick<LoadedFlowExtension, 'name' | 'handlers'>; readonly handler: TriggerHandler } | undefined {
   if (dispatch === undefined) return undefined;
   const identity = hostedEventIdentity(dispatch);
-  const matches = extensions.flatMap(extension => extension.handlers.flatMap(handler => {
-    const subscription = subscriptionOf(handler);
-    if (subscription === undefined || subscription.provider !== identity.provider || subscription.event !== identity.event) return [];
-    if (subscription.action !== undefined && subscription.action !== identity.action) return [];
-    return [{ extension, handler }];
-  }));
+  const matches: Array<{
+    extension: Pick<LoadedFlowExtension, 'name' | 'handlers'>;
+    handler: TriggerHandler;
+  }> = [];
+  for (let extensionIndex = 0; extensionIndex < extensions.length; extensionIndex += 1) {
+    const extension = extensions[extensionIndex]!;
+    for (let handlerIndex = 0; handlerIndex < extension.handlers.length; handlerIndex += 1) {
+      const handler = extension.handlers[handlerIndex]!;
+      const subscription = subscriptionOf(handler);
+      if (subscription === undefined || subscription.provider !== identity.provider
+        || subscription.event !== identity.event) continue;
+      if (subscription.action !== undefined && subscription.action !== identity.action) continue;
+      appendIntrinsicArray(matches, { extension, handler });
+    }
+  }
   if (matches.length > 1) {
+    let matchingNames = '';
+    for (let index = 0; index < matches.length; index += 1) {
+      matchingNames += `${index === 0 ? '' : ', '}${matches[index]!.extension.name}`;
+    }
     throw new PluginError(
       'plugin_event_ambiguous',
-      `Hosted event ${identity.provider}.${identity.event}${identity.action === undefined ? '' : `.${identity.action}`} matches multiple extension handlers (${matches.map(match => match.extension.name).join(', ')}).`,
+      `Hosted event ${identity.provider}.${identity.event}${identity.action === undefined ? '' : `.${identity.action}`} matches multiple extension handlers (${matchingNames}).`,
     );
   }
   return matches[0];
@@ -206,11 +240,12 @@ async function loadOne<Authority>(
   options: LoadFlowExtensionsOptions<Authority>,
 ): Promise<LoadedFlowExtension> {
   const directory = pluginStoreDirectory(root, lock.name, lock.digest);
-  await verifyStoredPlugin(directory, lock.digest);
-  const manifestBytes = readFileSync(join(directory, 'flows-plugin.json'));
+  const stored = await readStoredPluginFiles(directory, lock.digest);
+  const manifestBytes = stored.find(file => file.path === 'flows-plugin.json')?.data;
+  if (manifestBytes === undefined) throw new PluginError('plugin_source_drift', `${ref}: flows-plugin.json is missing.`);
   if (sha256(manifestBytes) !== lock.manifestSha256) throw new PluginError('plugin_source_drift', `${ref}: flows-plugin.json differs from the lockfile's manifest hash.`);
   let input: unknown;
-  try { input = JSON.parse(manifestBytes.toString('utf8')); }
+  try { input = JSON_PARSE(manifestBytes.toString('utf8')); }
   catch { throw new PluginError('plugin_manifest_invalid', `${ref}: flows-plugin.json is not valid JSON.`); }
   const manifest = validateFlowExtensionManifest(input);
   if (manifest.name !== lock.name || manifest.version !== lock.version) throw new PluginError('plugin_source_drift', `${ref}: manifest names ${manifest.name}@${manifest.version}, lockfile has ${lock.name}@${lock.version}.`);

package/src/fs-descriptor.ts

@@ -0,0 +1,127 @@
+import {
+  Dir,
+  Dirent,
+  Stats,
+  close,
+  fstat,
+  lstat,
+  open,
+  opendir,
+  read,
+  readdir,
+  type BigIntStats,
+  type PathLike,
+} from 'node:fs';
+import { hostedPromiseValue } from './hosted-promise-safety.js';
+
+const CLOSE = close;
+const FSTAT = fstat;
+const LSTAT = lstat;
+const OPEN = open;
+const OPENDIR = opendir;
+const READ = read;
+const READDIR = readdir;
+const PROMISE = Promise;
+const DIRENT_IS_DIRECTORY = Function.prototype.call.bind(Dirent.prototype.isDirectory) as (
+  entry: Dirent,
+) => boolean;
+const DIRENT_IS_FILE = Function.prototype.call.bind(Dirent.prototype.isFile) as (
+  entry: Dirent,
+) => boolean;
+const DIR_CLOSE = Function.prototype.call.bind(Dir.prototype.close) as (
+  directory: Dir,
+  callback: (error?: NodeJS.ErrnoException | null) => void,
+) => void;
+const DIR_READ = Function.prototype.call.bind(Dir.prototype.read) as (
+  directory: Dir,
+  callback: (error: NodeJS.ErrnoException | null, entry: Dirent | null) => void,
+) => void;
+const STATS_IS_DIRECTORY = Function.prototype.call.bind(Stats.prototype.isDirectory) as (
+  stats: Stats | BigIntStats,
+) => boolean;
+const STATS_IS_FILE = Function.prototype.call.bind(Stats.prototype.isFile) as (
+  stats: Stats | BigIntStats,
+) => boolean;
+
+export const descriptorIsDirectory = STATS_IS_DIRECTORY;
+export const descriptorIsFile = STATS_IS_FILE;
+export const directoryEntryIsDirectory = DIRENT_IS_DIRECTORY;
+export const directoryEntryIsFile = DIRENT_IS_FILE;
+
+export function closeDescriptor(descriptor: number): Promise<void> {
+  return new PROMISE<void>((resolvePromise, rejectPromise) => {
+    CLOSE(descriptor, error => error === null ? resolvePromise() : rejectPromise(error));
+  });
+}
+
+export function openDescriptor(path: PathLike, flags: number): Promise<number> {
+  return new PROMISE<number>((resolvePromise, rejectPromise) => {
+    OPEN(path, flags, (error, descriptor) => error === null ? resolvePromise(descriptor) : rejectPromise(error));
+  });
+}
+
+export function statDescriptor(descriptor: number, options: { bigint: true }): Promise<BigIntStats> {
+  return new PROMISE<BigIntStats>((resolvePromise, rejectPromise) => {
+    FSTAT(descriptor, options, (error, stats) => {
+      if (error !== null) rejectPromise(error);
+      else resolvePromise(hostedPromiseValue(stats));
+    });
+  });
+}
+
+export function lstatPath(path: PathLike): Promise<Stats> {
+  return new PROMISE<Stats>((resolvePromise, rejectPromise) => {
+    LSTAT(path, (error, stats) => {
+      if (error !== null) rejectPromise(error);
+      else resolvePromise(hostedPromiseValue(stats));
+    });
+  });
+}
+
+export function openDirectory(path: PathLike): Promise<Dir> {
+  return new PROMISE<Dir>((resolvePromise, rejectPromise) => {
+    OPENDIR(path, (error, directory) => {
+      if (error !== null) rejectPromise(error);
+      else resolvePromise(hostedPromiseValue(directory));
+    });
+  });
+}
+
+export function readDirectory(path: PathLike): Promise<Dirent[]> {
+  return new PROMISE<Dirent[]>((resolvePromise, rejectPromise) => {
+    READDIR(path, { withFileTypes: true }, (error, entries) => {
+      if (error !== null) rejectPromise(error);
+      else resolvePromise(hostedPromiseValue(entries));
+    });
+  });
+}
+
+export function readDirectoryEntry(directory: Dir): Promise<Dirent | null> {
+  return new PROMISE<Dirent | null>((resolvePromise, rejectPromise) => {
+    DIR_READ(directory, (error, entry) => {
+      if (error !== null) rejectPromise(error);
+      else resolvePromise(entry === null ? null : hostedPromiseValue(entry));
+    });
+  });
+}
+
+export function closeDirectory(directory: Dir): Promise<void> {
+  return new PROMISE<void>((resolvePromise, rejectPromise) => {
+    DIR_CLOSE(directory, error => error == null ? resolvePromise() : rejectPromise(error));
+  });
+}
+
+export async function readDescriptor(
+  descriptor: number,
+  buffer: Buffer,
+  offset: number,
+  length: number,
+  position: number,
+): Promise<number> {
+  return await new PROMISE<number>((resolvePromise, rejectPromise) => {
+    READ(descriptor, buffer, offset, length, position, (error, bytesRead) => {
+      if (error !== null) rejectPromise(error);
+      else resolvePromise(bytesRead);
+    });
+  });
+}