@poe-platform/safe-bash 0.1.814 → 0.1.815

package/dist/mp4-ast/index.d.ts

@@ -10,3 +10,4 @@ export * from "./containers/adapters.js";
 export * from "./containers/streaming.js";
 export { decodeH264Samples } from "./h264.js";
 export { scanMp4SampleTable, type Mp4SampleTables, type Mp4TableRange, type Mp4SampleSpan, type Mp4SampleScanOptions } from "./mp4-sample-source.js";
+export { scanMp4Fragment, type Mp4FragmentDefaults, type Mp4FragmentState, type Mp4FragmentScanOptions } from "./mp4-fragment-source.js";

package/dist/mp4-ast/mp4-fragment-source.d.ts

@@ -0,0 +1,35 @@
+import { type Mp4BoxScanOptions } from './mp4-source.js';
+import { type Mp4SampleSteps, type Mp4SampleSpan, type Mp4SampleScanOptions, type Mp4TableRange } from './mp4-sample-source.js';
+import type { MediaProbeSource } from './types.js';
+export interface Mp4FragmentDefaults {
+    readonly defaultSampleDescriptionIndex: number;
+    readonly defaultSampleDuration: number;
+    readonly defaultSampleSize: number;
+    readonly defaultSampleFlags: number;
+}
+export interface Mp4FragmentState {
+    readonly dts: number;
+    readonly sampleCount: number;
+}
+export interface Mp4FragmentScanOptions extends Omit<Mp4SampleScanOptions, 'syncSamples'> {
+    readonly trackId: number;
+    readonly moofOffset: number;
+    readonly defaults: Mp4FragmentDefaults;
+    /** Carry the end of the last retained sample and count across classic tables and fragments. */
+    readonly state?: Mp4FragmentState;
+}
+interface FragmentHeader extends Mp4FragmentDefaults {
+    readonly baseDataOffset: number;
+}
+/** Shared header interpretation, including the resident reader's truncated-field zeros. */
+export declare function mp4FragmentHeader(bytes: Uint8Array, options: Mp4FragmentScanOptions): FragmentHeader | undefined;
+export declare function mp4FragmentTime(bytes: Uint8Array, fallback: number): number;
+/** Traverse a single run without retaining its rows or payload. */
+export declare function mp4FragmentRunSteps(size: number, table: Mp4TableRange, header: FragmentHeader, state: Mp4FragmentState, options: Mp4SampleScanOptions): Mp4SampleSteps<Mp4FragmentState>;
+/**
+ * Replay one traf's children. Two sibling scans keep headers independent of box order
+ * without collecting runs. Returns carried state even when tfdt has no samples.
+ * Source ownership, trex lookup, track iteration and staged publication belong to the caller.
+ */
+export declare function scanMp4Fragment(source: MediaProbeSource, range: Pick<Mp4BoxScanOptions, 'offset' | 'length' | 'depth'>, options: Mp4FragmentScanOptions): AsyncGenerator<Mp4SampleSpan, Mp4FragmentState>;
+export {};

package/dist/mp4-ast/mp4-sample-source.d.ts

@@ -40,13 +40,16 @@ type Step = {
     kind: 'sample';
     sample: Mp4SampleSpan;
 };
-type Steps<T> = Generator<Step, T, Uint8Array | boolean | undefined>;
+export type Mp4SampleSteps<T> = Generator<Step, T, Uint8Array | boolean | undefined>;
 /** One traversal shared by the resident parser and asynchronous caller ranges. */
-export declare function mp4SampleTableSteps(size: number, tables: Mp4SampleTables, options?: Pick<Mp4SampleScanOptions, 'type' | 'budget'>): Steps<void>;
+export declare function mp4SampleTableSteps(size: number, tables: Mp4SampleTables, options?: Pick<Mp4SampleScanOptions, 'type' | 'budget'>): Mp4SampleSteps<void>;
 /**
  * Replay a classic (non-fragmented) stbl without materializing tables or payloads.
  * At most seven 16 KiB table pages are cached; sync membership belongs to the caller.
  * Input/index lifetime, publication after validation, and fragmented runs remain caller-owned.
  */
 export declare function scanMp4SampleTable(source: MediaProbeSource, tables: Mp4SampleTables, options?: Mp4SampleScanOptions): AsyncGenerator<Mp4SampleSpan, void>;
+export declare function readMp4SampleRange(source: MediaProbeSource, offset: number, length: number, options: Mp4SampleScanOptions): Promise<Uint8Array>;
+/** Drive the shared sample traversal with bounded owned table pages. */
+export declare function consumeMp4SampleSteps<T>(source: MediaProbeSource, steps: Mp4SampleSteps<T>, options: Mp4SampleScanOptions): AsyncGenerator<Mp4SampleSpan, T>;
 export {};

package/dist/mp4-ast/types.d.ts

@@ -375,6 +375,15 @@ export type MediaProbeRecords = Omit<MediaProbeResult, "packets" | "frames"> & {
     readonly packets?: Iterable<MediaProbePacket> | undefined;
     readonly frames?: Iterable<MediaProbeFrame> | undefined;
 };
+/** Caller-backed, one-shot record sources. Consume before retiring the input source. */
+export type MediaProbeSourceRecords = Omit<MediaProbeResult, "streams" | "chapters" | "packets" | "frames"> & {
+    /** Retire plugin-owned backing after all requested records, including unselected sections. */
+    readonly close?: () => Promise<void>;
+    readonly streams: Iterable<MediaProbeStream> | AsyncIterable<MediaProbeStream>;
+    readonly chapters: Iterable<MediaProbeResult["chapters"][number]> | AsyncIterable<MediaProbeResult["chapters"][number]>;
+    readonly packets?: Iterable<MediaProbePacket> | AsyncIterable<MediaProbePacket> | undefined;
+    readonly frames?: Iterable<MediaProbeFrame> | AsyncIterable<MediaProbeFrame> | undefined;
+};
 export interface MediaSourceProbeOptions extends ParseMediaOptions {
     readonly signal?: AbortSignal;
     readonly showPackets?: boolean;
@@ -463,6 +472,8 @@ export interface MediaAstPlugin {
         showPackets?: boolean;
         showFrames?: boolean;
     }): MediaProbeResult;
+    /** Lazy caller-backed records; source remains alive through complete enumeration. */
+    probeRecords?(source: MediaProbeSource, options?: MediaSourceProbeOptions): Promise<MediaProbeSourceRecords>;
     /** Optional bounded range path; packet/frame descriptors may be lazy iterables. */
     probeMetadata?(source: MediaProbeSource, options?: MediaSourceProbeOptions): Promise<MediaProbeRecords>;
     /** Optional bounded sequential metadata path; consumes input through EOF. */

package/dist/pdf-ast/cos/object-reader.d.ts

@@ -17,7 +17,7 @@ export interface PdfObjectReaderOptions extends Omit<ParseCosRangeOptions, "reso
     /** Aggregate decoded object-stream data and header tape bytes. */
     readonly maxStagingBytes?: number;
     readonly maxObjectStreamMembers?: number;
-    /** Live ancestor-index staging for each indirect length traversal. */
+    /** Live ancestor-index staging for each indirect reference traversal. */
     readonly maxTraversalStagingBytes?: number;
 }
 /** Raw indexed COS access. The source and xref index remain caller-owned.
@@ -31,7 +31,7 @@ export declare class PdfObjectReader {
     private readonly storage;
     private readonly streams;
     private readonly backingFailures;
-    private readonly lengthPaths;
+    private readonly referencePaths;
     private readonly repairedOffsets;
     private readonly options;
     private readonly capacity;
@@ -45,6 +45,7 @@ export declare class PdfObjectReader {
     /** Decode one retained stream under consumer backpressure. The caller owns
      * the source and must keep it open until iteration finishes. */
     decodeStream(objectNumber: number, generationNumber?: number, options?: Pick<PdfStreamDecodeOptions, "stopBeforeImageCodec" | "raw">): AsyncGenerator<Uint8Array, void, void>;
+    private resolveStreamDictionary;
     /** A stream-valued /Length is invalid as a length, but its references still
      * need cycle, admission and backing-error validation. Walk those discarded
      * values in source order instead of retaining one parser and AST per link. */

package/dist/pdf-ast/edit/forms.d.ts

@@ -16,5 +16,6 @@ export declare function getDocumentFormFields(doc: ParsedCosDocument): PdfFormFi
 export declare function setDocumentFormField(doc: ParsedCosDocument, fieldName: string, value: string | boolean): void;
 export declare function generateDocumentFormAppearancesSteps(doc: ParsedCosDocument): Generator<void, void, void>;
 export declare function generateDocumentFormAppearances(doc: ParsedCosDocument): void;
+export declare function decodeFormDataEntities(text: string): string;
 export declare function parseFormDataBytes(bytes: Uint8Array): Map<string, string | boolean>;
 export declare function flattenDocumentFormFields(doc: ParsedCosDocument): void;

package/dist/pdf-ast/edit/retained-form-data.d.ts

@@ -0,0 +1,9 @@
+import type { PdfIndexStorage } from "../cos/object-index.js";
+import type { PdfFileSource } from "../source.js";
+import type { RetainedFormUpdate } from "./retained-form-appearances.js";
+/** Consume a retained form-data source and yield final fields in first-seen
+ * order. Input text, FDF tokens, names and overwrite state use caller storage.
+ * Individual field names/values and lexical tokens remain resident. */
+export declare function parseRetainedFormData(source: PdfFileSource, storage: PdfIndexStorage, options?: {
+    readonly signal?: AbortSignal;
+}): AsyncGenerator<RetainedFormUpdate>;

package/dist/pdf-ast/index.d.ts

@@ -79,3 +79,4 @@ export { replaceRetainedPdfName } from "./edit/retained-name-replacement.js";
 export { QpdfJsonValues } from "./cos/qpdf-json-values.js";
 export { QpdfJsonDocument, type ApplyQpdfJsonOptions } from "./cos/qpdf-json-document.js";
 export type { RetainedAppendAttachment } from "./edit/retained-append-attachments.js";
+export { parseRetainedFormData } from "./edit/retained-form-data.js";