@opensteer/runtime-core 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,766 @@
+import { BrowserCoreEngine, PageRef, NetworkRecord, HeaderEntry, BodyPayload, SessionRef } from '@opensteer/browser-core';
+import { OpensteerSemanticOperationName, OpensteerArtifactKind, ArtifactProvenance, TraceContext, HtmlSnapshot, DomSnapshot, CookieRecord, StorageSnapshot, ScriptSourceArtifactData, ArtifactRelation, ArtifactReference, OpensteerArtifact, OpensteerRequestPlanPayload, OpensteerRequestPlanLifecycle, OpensteerRequestPlanFreshness, OpensteerAuthRecipePayload, OpensteerRecipePayload, OpensteerReverseCasePayload, OpensteerInteractionTracePayload, OpensteerReversePackagePayload, OpensteerReverseReportPayload, NetworkQueryRecord, NetworkResourceType, TraceOutcome, OpensteerEvent, OpensteerError, TraceRecord, TraceBundle, OpensteerBrowserOptions, OpensteerBrowserLaunchOptions, OpensteerBrowserContextOptions, OpensteerSessionInfo, OpensteerOpenInput, OpensteerOpenOutput, OpensteerPageListInput, OpensteerPageListOutput, OpensteerPageNewInput, OpensteerPageNewOutput, OpensteerPageActivateInput, OpensteerPageActivateOutput, OpensteerPageCloseInput, OpensteerPageCloseOutput, OpensteerPageGotoInput, OpensteerPageGotoOutput, OpensteerPageEvaluateInput, OpensteerPageEvaluateOutput, OpensteerAddInitScriptInput, OpensteerAddInitScriptOutput, OpensteerPageSnapshotInput, OpensteerPageSnapshotOutput, OpensteerDomClickInput, OpensteerActionResult, OpensteerDomHoverInput, OpensteerDomInputInput, OpensteerDomScrollInput, OpensteerDomExtractInput, OpensteerDomExtractOutput, OpensteerNetworkQueryInput, OpensteerNetworkQueryOutput, OpensteerNetworkSaveInput, OpensteerNetworkSaveOutput, OpensteerNetworkClearInput, OpensteerNetworkClearOutput, OpensteerCaptureScriptsInput, OpensteerCaptureScriptsOutput, OpensteerNetworkMinimizeInput, OpensteerNetworkMinimizeOutput, OpensteerNetworkDiffInput, OpensteerNetworkDiffOutput, OpensteerArtifactReadInput, OpensteerArtifactReadOutput, OpensteerTransportProbeInput, OpensteerTransportProbeOutput, OpensteerReverseDiscoverInput, OpensteerReverseDiscoverOutput, OpensteerReverseQueryInput, OpensteerReverseQueryOutput, OpensteerReversePackageCreateInput, OpensteerReversePackageCreateOutput, OpensteerReversePackageRunInput, OpensteerReversePackageRunOutput, OpensteerReverseExportInput, OpensteerReverseExportOutput, OpensteerReverseReportInput, OpensteerReverseReportOutput, OpensteerReversePackageGetInput, OpensteerReversePackageGetOutput, OpensteerReversePackageListInput, OpensteerReversePackageListOutput, OpensteerReversePackagePatchInput, OpensteerReversePackagePatchOutput, OpensteerInteractionCaptureInput, OpensteerInteractionCaptureOutput, OpensteerInteractionGetInput, OpensteerInteractionGetOutput, OpensteerInteractionDiffInput, OpensteerInteractionDiffOutput, OpensteerInteractionReplayInput, OpensteerInteractionReplayOutput, OpensteerScriptBeautifyInput, OpensteerScriptBeautifyOutput, OpensteerScriptDeobfuscateInput, OpensteerScriptDeobfuscateOutput, OpensteerScriptSandboxInput, OpensteerScriptSandboxOutput, OpensteerCaptchaSolveInput, OpensteerCaptchaSolveOutput, OpensteerInferRequestPlanInput, OpensteerWriteRequestPlanInput, OpensteerGetRequestPlanInput, OpensteerListRequestPlansInput, OpensteerListRequestPlansOutput, OpensteerWriteAuthRecipeInput, OpensteerWriteRecipeInput, OpensteerGetAuthRecipeInput, OpensteerGetRecipeInput, OpensteerListAuthRecipesInput, OpensteerListAuthRecipesOutput, OpensteerListRecipesInput, OpensteerListRecipesOutput, OpensteerRunAuthRecipeInput, OpensteerRunAuthRecipeOutput, OpensteerRunRecipeInput, OpensteerRunRecipeOutput, OpensteerRawRequestInput, OpensteerRawRequestOutput, OpensteerRequestExecuteInput, OpensteerRequestExecuteOutput, OpensteerComputerExecuteInput, OpensteerComputerExecuteOutput, OpensteerSessionCloseOutput } from '@opensteer/protocol';
+
+declare const OPENSTEER_RUNTIME_CORE_VERSION: string;
+
+interface TimeoutResolutionInput {
+    readonly operation: OpensteerSemanticOperationName;
+    readonly signal?: AbortSignal;
+}
+interface TimeoutPolicy {
+    resolveTimeoutMs(input: TimeoutResolutionInput): number | undefined;
+}
+type SettleTrigger = "navigation" | "dom-action" | "snapshot";
+interface SettleDelayInput {
+    readonly operation: OpensteerSemanticOperationName;
+    readonly trigger: SettleTrigger;
+}
+interface SettleContext extends SettleDelayInput {
+    readonly engine: BrowserCoreEngine;
+    readonly pageRef: PageRef;
+    readonly signal: AbortSignal;
+    readonly remainingMs: number | undefined;
+}
+interface SettleObserver {
+    settle(input: SettleContext): Promise<boolean>;
+}
+interface SettlePolicy {
+    readonly observers?: readonly SettleObserver[];
+    resolveDelayMs(input: SettleDelayInput): number;
+}
+interface RetryEvaluationInput {
+    readonly operation: OpensteerSemanticOperationName;
+    readonly error: unknown;
+}
+interface RetryDecision {
+    readonly retry: false;
+}
+interface RetryPolicy {
+    evaluate(input: RetryEvaluationInput): RetryDecision | Promise<RetryDecision>;
+}
+interface FallbackEvaluationInput {
+    readonly operation: OpensteerSemanticOperationName;
+    readonly error: unknown;
+}
+interface FallbackDecision {
+    readonly fallback: false;
+}
+interface FallbackPolicy {
+    evaluate(input: FallbackEvaluationInput): FallbackDecision | Promise<FallbackDecision>;
+}
+interface OpensteerPolicy {
+    readonly timeout: TimeoutPolicy;
+    readonly settle: SettlePolicy;
+    readonly retry: RetryPolicy;
+    readonly fallback: FallbackPolicy;
+}
+
+type ArtifactPayloadType = "structured" | "binary";
+type ProtocolArtifactDelivery = "external" | "inline-if-structured";
+interface ArtifactScope extends TraceContext {
+}
+interface ArtifactManifest {
+    readonly artifactId: string;
+    readonly kind: OpensteerArtifactKind;
+    readonly createdAt: number;
+    readonly provenance?: ArtifactProvenance;
+    readonly scope: ArtifactScope;
+    readonly mediaType: string;
+    readonly payloadType: ArtifactPayloadType;
+    readonly byteLength: number;
+    readonly sha256: string;
+    readonly objectRelativePath: string;
+}
+type StructuredArtifactKind = Exclude<OpensteerArtifactKind, "screenshot">;
+interface StructuredArtifactDataByKind {
+    readonly "html-snapshot": HtmlSnapshot;
+    readonly "dom-snapshot": DomSnapshot;
+    readonly cookies: readonly CookieRecord[];
+    readonly "storage-snapshot": StorageSnapshot;
+    readonly "script-source": ScriptSourceArtifactData;
+}
+type StructuredArtifactPayloadByKind = {
+    [K in StructuredArtifactKind]: {
+        readonly kind: K;
+        readonly payloadType: "structured";
+        readonly data: StructuredArtifactDataByKind[K];
+    };
+};
+type StoredArtifactPayloadByKind = {
+    readonly screenshot: {
+        readonly kind: "screenshot";
+        readonly payloadType: "binary";
+        readonly data: Uint8Array;
+    };
+} & StructuredArtifactPayloadByKind;
+type StoredArtifactPayload = StoredArtifactPayloadByKind[OpensteerArtifactKind];
+interface StoredArtifactRecord {
+    readonly manifest: ArtifactManifest;
+    readonly payload: StoredArtifactPayload;
+}
+type WriteStructuredArtifactInputByKind<K extends StructuredArtifactKind> = {
+    readonly artifactId?: string;
+    readonly kind: K;
+    readonly createdAt?: number;
+    readonly provenance?: ArtifactProvenance;
+    readonly scope?: ArtifactScope;
+    readonly mediaType?: string;
+    readonly data: StructuredArtifactDataByKind[K];
+};
+type WriteStructuredArtifactInput = {
+    [K in StructuredArtifactKind]: WriteStructuredArtifactInputByKind<K>;
+}[StructuredArtifactKind];
+interface WriteBinaryArtifactInput {
+    readonly artifactId?: string;
+    readonly kind: "screenshot";
+    readonly createdAt?: number;
+    readonly provenance?: ArtifactProvenance;
+    readonly scope?: ArtifactScope;
+    readonly mediaType: string;
+    readonly data: Uint8Array;
+}
+interface OpensteerArtifactStore {
+    readonly manifestsDirectory: string;
+    readonly objectsDirectory: string;
+    writeStructured(input: WriteStructuredArtifactInput): Promise<ArtifactManifest>;
+    writeBinary(input: WriteBinaryArtifactInput): Promise<ArtifactManifest>;
+    getManifest(artifactId: string): Promise<ArtifactManifest | undefined>;
+    read(artifactId: string): Promise<StoredArtifactRecord | undefined>;
+    toProtocolArtifactReference(artifactId: string, relation: ArtifactRelation): Promise<ArtifactReference | undefined>;
+    toProtocolArtifact(artifactId: string, options?: {
+        readonly delivery?: ProtocolArtifactDelivery;
+    }): Promise<OpensteerArtifact | undefined>;
+}
+
+type JsonPrimitive = boolean | number | string | null;
+type JsonValue = JsonPrimitive | JsonObject | JsonArray;
+interface JsonObject {
+    readonly [key: string]: JsonValue;
+}
+type JsonArray = readonly JsonValue[];
+
+interface RegistryProvenance {
+    readonly source: string;
+    readonly sourceId?: string;
+    readonly capturedAt?: number;
+    readonly notes?: string;
+}
+interface RegistryRecord<TPayload = JsonValue> {
+    readonly id: string;
+    readonly key: string;
+    readonly version: string;
+    readonly createdAt: number;
+    readonly updatedAt: number;
+    readonly contentHash: string;
+    readonly tags: readonly string[];
+    readonly provenance?: RegistryProvenance;
+    readonly payload: TPayload;
+}
+type DescriptorRecord = RegistryRecord;
+type AuthRecipeRecord = RegistryRecord<OpensteerAuthRecipePayload>;
+type RecipeRecord = RegistryRecord<OpensteerRecipePayload>;
+type InteractionTraceRecord = RegistryRecord<OpensteerInteractionTracePayload>;
+type ReverseCaseRecord = RegistryRecord<OpensteerReverseCasePayload>;
+type ReversePackageRecord = RegistryRecord<OpensteerReversePackagePayload>;
+type ReverseReportRecord = RegistryRecord<OpensteerReverseReportPayload>;
+type RequestPlanLifecycle = OpensteerRequestPlanLifecycle;
+type RequestPlanFreshness = OpensteerRequestPlanFreshness;
+interface RequestPlanRecord extends RegistryRecord<OpensteerRequestPlanPayload> {
+    readonly lifecycle: RequestPlanLifecycle;
+    readonly freshness?: RequestPlanFreshness;
+}
+interface ResolveRegistryRecordInput {
+    readonly key: string;
+    readonly version?: string;
+}
+interface WriteDescriptorInput<TPayload = JsonValue> {
+    readonly id?: string;
+    readonly key: string;
+    readonly version: string;
+    readonly createdAt?: number;
+    readonly updatedAt?: number;
+    readonly tags?: readonly string[];
+    readonly provenance?: RegistryProvenance;
+    readonly payload: TPayload;
+}
+interface WriteRequestPlanInput extends WriteDescriptorInput<OpensteerRequestPlanPayload> {
+    readonly lifecycle?: RequestPlanLifecycle;
+    readonly freshness?: RequestPlanFreshness;
+}
+interface WriteAuthRecipeInput extends WriteDescriptorInput<OpensteerAuthRecipePayload> {
+}
+interface WriteRecipeInput extends WriteDescriptorInput<OpensteerRecipePayload> {
+}
+interface WriteInteractionTraceInput extends WriteDescriptorInput<OpensteerInteractionTracePayload> {
+}
+interface WriteReverseCaseInput extends WriteDescriptorInput<OpensteerReverseCasePayload> {
+}
+interface WriteReversePackageInput extends WriteDescriptorInput<OpensteerReversePackagePayload> {
+}
+interface WriteReverseReportInput extends WriteDescriptorInput<OpensteerReverseReportPayload> {
+}
+interface ListRegistryRecordsInput {
+    readonly key?: string;
+}
+interface UpdateRequestPlanMetadataInput {
+    readonly id: string;
+    readonly updatedAt?: number;
+    readonly lifecycle?: RequestPlanLifecycle;
+    readonly freshness?: RequestPlanFreshness;
+}
+interface UpdateReverseCaseInput {
+    readonly id: string;
+    readonly updatedAt?: number;
+    readonly tags?: readonly string[];
+    readonly provenance?: RegistryProvenance;
+    readonly payload: OpensteerReverseCasePayload;
+}
+interface DescriptorRegistryStore {
+    readonly recordsDirectory: string;
+    readonly indexesDirectory: string;
+    write(input: WriteDescriptorInput): Promise<DescriptorRecord>;
+    getById(id: string): Promise<DescriptorRecord | undefined>;
+    resolve(input: ResolveRegistryRecordInput): Promise<DescriptorRecord | undefined>;
+}
+interface RequestPlanRegistryStore {
+    readonly recordsDirectory: string;
+    readonly indexesDirectory: string;
+    write(input: WriteRequestPlanInput): Promise<RequestPlanRecord>;
+    getById(id: string): Promise<RequestPlanRecord | undefined>;
+    list(input?: ListRegistryRecordsInput): Promise<readonly RequestPlanRecord[]>;
+    resolve(input: ResolveRegistryRecordInput): Promise<RequestPlanRecord | undefined>;
+    updateMetadata(input: UpdateRequestPlanMetadataInput): Promise<RequestPlanRecord>;
+}
+interface AuthRecipeRegistryStore {
+    readonly recordsDirectory: string;
+    readonly indexesDirectory: string;
+    write(input: WriteAuthRecipeInput): Promise<AuthRecipeRecord>;
+    getById(id: string): Promise<AuthRecipeRecord | undefined>;
+    list(input?: ListRegistryRecordsInput): Promise<readonly AuthRecipeRecord[]>;
+    resolve(input: ResolveRegistryRecordInput): Promise<AuthRecipeRecord | undefined>;
+}
+interface RecipeRegistryStore extends AuthRecipeRegistryStore {
+    write(input: WriteRecipeInput): Promise<RecipeRecord>;
+    getById(id: string): Promise<RecipeRecord | undefined>;
+    list(input?: ListRegistryRecordsInput): Promise<readonly RecipeRecord[]>;
+    resolve(input: ResolveRegistryRecordInput): Promise<RecipeRecord | undefined>;
+}
+interface InteractionTraceRegistryStore {
+    readonly recordsDirectory: string;
+    readonly indexesDirectory: string;
+    write(input: WriteInteractionTraceInput): Promise<InteractionTraceRecord>;
+    getById(id: string): Promise<InteractionTraceRecord | undefined>;
+    list(input?: ListRegistryRecordsInput): Promise<readonly InteractionTraceRecord[]>;
+    resolve(input: ResolveRegistryRecordInput): Promise<InteractionTraceRecord | undefined>;
+}
+interface ReverseCaseRegistryStore {
+    readonly recordsDirectory: string;
+    readonly indexesDirectory: string;
+    write(input: WriteReverseCaseInput): Promise<ReverseCaseRecord>;
+    getById(id: string): Promise<ReverseCaseRecord | undefined>;
+    list(input?: ListRegistryRecordsInput): Promise<readonly ReverseCaseRecord[]>;
+    resolve(input: ResolveRegistryRecordInput): Promise<ReverseCaseRecord | undefined>;
+    update(input: UpdateReverseCaseInput): Promise<ReverseCaseRecord>;
+}
+interface ReversePackageRegistryStore {
+    readonly recordsDirectory: string;
+    readonly indexesDirectory: string;
+    write(input: WriteReversePackageInput): Promise<ReversePackageRecord>;
+    getById(id: string): Promise<ReversePackageRecord | undefined>;
+    list(input?: ListRegistryRecordsInput): Promise<readonly ReversePackageRecord[]>;
+    resolve(input: ResolveRegistryRecordInput): Promise<ReversePackageRecord | undefined>;
+}
+interface ReverseReportRegistryStore {
+    readonly recordsDirectory: string;
+    readonly indexesDirectory: string;
+    write(input: WriteReverseReportInput): Promise<ReverseReportRecord>;
+    getById(id: string): Promise<ReverseReportRecord | undefined>;
+    list(input?: ListRegistryRecordsInput): Promise<readonly ReverseReportRecord[]>;
+    resolve(input: ResolveRegistryRecordInput): Promise<ReverseReportRecord | undefined>;
+}
+
+interface SavedNetworkQueryInput {
+    readonly recordId?: string;
+    readonly requestId?: string;
+    readonly actionId?: string;
+    readonly tag?: string;
+    readonly url?: string;
+    readonly hostname?: string;
+    readonly path?: string;
+    readonly method?: string;
+    readonly status?: string;
+    readonly resourceType?: NetworkResourceType;
+    readonly includeBodies?: boolean;
+    readonly limit?: number;
+}
+interface SavedNetworkStore {
+    readonly databasePath: string;
+    initialize(): Promise<void>;
+    save(records: readonly NetworkQueryRecord[], tag?: string): Promise<number>;
+    query(input?: SavedNetworkQueryInput): Promise<readonly NetworkQueryRecord[]>;
+    getByRecordId(recordId: string, options?: {
+        readonly includeBodies?: boolean;
+    }): Promise<NetworkQueryRecord | undefined>;
+    clear(input?: {
+        readonly tag?: string;
+    }): Promise<number>;
+}
+
+interface TraceRunManifest {
+    readonly runId: string;
+    readonly createdAt: number;
+    readonly updatedAt: number;
+    readonly entryCount: number;
+}
+interface CreateTraceRunInput {
+    readonly runId?: string;
+    readonly createdAt?: number;
+}
+interface AppendTraceEntryInput<TData extends JsonValue = JsonValue> {
+    readonly traceId?: string;
+    readonly stepId?: string;
+    readonly operation: string;
+    readonly outcome: TraceOutcome;
+    readonly startedAt: number;
+    readonly completedAt: number;
+    readonly context?: TraceContext;
+    readonly events?: readonly OpensteerEvent[];
+    readonly artifacts?: readonly ArtifactReference[];
+    readonly data?: TData;
+    readonly error?: OpensteerError;
+}
+interface TraceEntryRecord<TData extends JsonValue = JsonValue> {
+    readonly runId: string;
+    readonly sequence: number;
+    readonly traceId: string;
+    readonly stepId: string;
+    readonly operation: string;
+    readonly outcome: TraceOutcome;
+    readonly startedAt: number;
+    readonly completedAt: number;
+    readonly durationMs: number;
+    readonly context: TraceContext;
+    readonly events: readonly OpensteerEvent[];
+    readonly artifacts?: readonly ArtifactReference[];
+    readonly data?: TData;
+    readonly error?: OpensteerError;
+}
+interface OpensteerTraceStore {
+    readonly runsDirectory: string;
+    createRun(input?: CreateTraceRunInput): Promise<TraceRunManifest>;
+    getRun(runId: string): Promise<TraceRunManifest | undefined>;
+    append<TData extends JsonValue>(runId: string, input: AppendTraceEntryInput<TData>): Promise<TraceEntryRecord<TData>>;
+    listEntries(runId: string): Promise<readonly TraceEntryRecord[]>;
+    getEntry(runId: string, traceId: string): Promise<TraceEntryRecord | undefined>;
+    toProtocolTraceRecord<TData extends JsonValue>(entry: TraceEntryRecord<TData>): TraceRecord<TData>;
+    readProtocolTraceBundle(runId: string, traceId: string, options?: {
+        readonly artifactDelivery?: ProtocolArtifactDelivery;
+    }): Promise<TraceBundle | undefined>;
+}
+
+declare const OPENSTEER_FILESYSTEM_WORKSPACE_LAYOUT = "opensteer-workspace";
+declare const OPENSTEER_FILESYSTEM_WORKSPACE_VERSION = 2;
+interface OpensteerWorkspaceManifest {
+    readonly layout: typeof OPENSTEER_FILESYSTEM_WORKSPACE_LAYOUT;
+    readonly version: typeof OPENSTEER_FILESYSTEM_WORKSPACE_VERSION;
+    readonly scope: "workspace" | "temporary";
+    readonly workspace?: string;
+    readonly createdAt: number;
+    readonly updatedAt: number;
+    readonly paths: {
+        readonly browser: "browser";
+        readonly live: "live";
+        readonly artifacts: "artifacts";
+        readonly traces: "traces";
+        readonly registry: "registry";
+    };
+}
+interface CreateFilesystemOpensteerWorkspaceOptions {
+    readonly rootPath: string;
+    readonly workspace?: string;
+    readonly scope?: "workspace" | "temporary";
+    readonly createdAt?: number;
+}
+interface FilesystemOpensteerWorkspace {
+    readonly rootPath: string;
+    readonly manifestPath: string;
+    readonly manifest: OpensteerWorkspaceManifest;
+    readonly browserPath: string;
+    readonly browserManifestPath: string;
+    readonly browserUserDataDir: string;
+    readonly livePath: string;
+    readonly liveSessionPath: string;
+    readonly liveBrowserPath: string;
+    readonly artifactsPath: string;
+    readonly tracesPath: string;
+    readonly registryPath: string;
+    readonly lockPath: string;
+    readonly artifacts: OpensteerArtifactStore;
+    readonly traces: OpensteerTraceStore;
+    readonly registry: {
+        readonly descriptors: DescriptorRegistryStore;
+        readonly requestPlans: RequestPlanRegistryStore;
+        readonly authRecipes: AuthRecipeRegistryStore;
+        readonly recipes: RecipeRegistryStore;
+        readonly savedNetwork: SavedNetworkStore;
+        readonly reverseCases: ReverseCaseRegistryStore;
+        readonly interactionTraces: InteractionTraceRegistryStore;
+        readonly reversePackages: ReversePackageRegistryStore;
+        readonly reverseReports: ReverseReportRegistryStore;
+    };
+    lock<T>(task: () => Promise<T>): Promise<T>;
+}
+declare function normalizeWorkspaceId(workspace: string): string;
+declare function resolveFilesystemWorkspacePath(input: {
+    readonly rootDir: string;
+    readonly workspace: string;
+}): string;
+declare function createFilesystemOpensteerWorkspace(options: CreateFilesystemOpensteerWorkspaceOptions): Promise<FilesystemOpensteerWorkspace>;
+
+interface OpensteerRouteRequest {
+    readonly url: string;
+    readonly method: string;
+    readonly headers: readonly HeaderEntry[];
+    readonly resourceType: NetworkRecord["resourceType"];
+    readonly pageRef?: PageRef;
+    readonly postData?: BodyPayload;
+}
+interface OpensteerFetchedRouteResponse {
+    readonly url: string;
+    readonly status: number;
+    readonly statusText: string;
+    readonly headers: readonly HeaderEntry[];
+    readonly body?: BodyPayload;
+    readonly redirected: boolean;
+}
+type OpensteerRouteHandlerResult = {
+    readonly kind: "continue";
+} | {
+    readonly kind: "fulfill";
+    readonly status?: number;
+    readonly headers?: readonly HeaderEntry[];
+    readonly body?: string | Uint8Array;
+    readonly contentType?: string;
+} | {
+    readonly kind: "abort";
+    readonly errorCode?: string;
+};
+interface OpensteerRouteOptions {
+    readonly pageRef?: PageRef;
+    readonly urlPattern: string;
+    readonly resourceTypes?: readonly NetworkRecord["resourceType"][];
+    readonly times?: number;
+    readonly handler: (input: {
+        readonly request: OpensteerRouteRequest;
+        fetchOriginal(): Promise<OpensteerFetchedRouteResponse>;
+    }) => OpensteerRouteHandlerResult | Promise<OpensteerRouteHandlerResult>;
+}
+interface OpensteerRouteRegistration {
+    readonly routeId: string;
+    readonly sessionRef: SessionRef;
+    readonly pageRef?: PageRef;
+    readonly urlPattern: string;
+}
+interface OpensteerInterceptScriptOptions {
+    readonly pageRef?: PageRef;
+    readonly urlPattern: string;
+    readonly times?: number;
+    readonly handler: (input: {
+        readonly url: string;
+        readonly content: string;
+        readonly headers: readonly HeaderEntry[];
+        readonly status: number;
+    }) => string | Promise<string>;
+}
+
+interface OpensteerEngineFactoryOptions {
+    readonly browser?: OpensteerBrowserOptions;
+    readonly launch?: OpensteerBrowserLaunchOptions;
+    readonly context?: OpensteerBrowserContextOptions;
+}
+type OpensteerEngineFactory = (options: OpensteerEngineFactoryOptions) => Promise<BrowserCoreEngine>;
+type OpensteerRuntimeWorkspace = FilesystemOpensteerWorkspace;
+interface OpensteerSessionRuntimeOptions {
+    readonly name: string;
+    readonly workspace?: OpensteerRuntimeWorkspace;
+    readonly workspaceName?: string;
+    readonly rootPath?: string;
+    readonly engine?: BrowserCoreEngine;
+    readonly engineFactory?: OpensteerEngineFactory;
+    readonly policy?: OpensteerPolicy;
+    readonly cleanupRootOnClose?: boolean;
+    readonly sessionInfo?: Partial<Omit<OpensteerSessionInfo, "sessionId" | "activePageRef">>;
+}
+interface RuntimeOperationOptions {
+    readonly signal?: AbortSignal;
+}
+declare class OpensteerSessionRuntime {
+    readonly workspace: string;
+    readonly rootPath: string;
+    private readonly workspaceName;
+    private readonly injectedEngine;
+    private readonly engineFactory;
+    private readonly policy;
+    private readonly cleanupRootOnClose;
+    private readonly sessionInfoBase;
+    private root;
+    private engine;
+    private dom;
+    private computer;
+    private readonly networkJournal;
+    private extractionDescriptors;
+    private sessionRef;
+    private pageRef;
+    private runId;
+    private latestSnapshot;
+    private readonly backgroundNetworkPersistence;
+    private readonly cookieJars;
+    private readonly recipeCache;
+    private ownsEngine;
+    constructor(options: OpensteerSessionRuntimeOptions);
+    info(): Promise<OpensteerSessionInfo>;
+    open(input?: OpensteerOpenInput, options?: RuntimeOperationOptions): Promise<OpensteerOpenOutput>;
+    listPages(input?: OpensteerPageListInput, options?: RuntimeOperationOptions): Promise<OpensteerPageListOutput>;
+    newPage(input?: OpensteerPageNewInput, options?: RuntimeOperationOptions): Promise<OpensteerPageNewOutput>;
+    activatePage(input: OpensteerPageActivateInput, options?: RuntimeOperationOptions): Promise<OpensteerPageActivateOutput>;
+    closePage(input?: OpensteerPageCloseInput, options?: RuntimeOperationOptions): Promise<OpensteerPageCloseOutput>;
+    goto(input: OpensteerPageGotoInput, options?: RuntimeOperationOptions): Promise<OpensteerPageGotoOutput>;
+    evaluate(input: OpensteerPageEvaluateInput, options?: RuntimeOperationOptions): Promise<OpensteerPageEvaluateOutput>;
+    addInitScript(input: OpensteerAddInitScriptInput, options?: RuntimeOperationOptions): Promise<OpensteerAddInitScriptOutput>;
+    snapshot(input?: OpensteerPageSnapshotInput, options?: RuntimeOperationOptions): Promise<OpensteerPageSnapshotOutput>;
+    click(input: OpensteerDomClickInput, options?: RuntimeOperationOptions): Promise<OpensteerActionResult>;
+    hover(input: OpensteerDomHoverInput, options?: RuntimeOperationOptions): Promise<OpensteerActionResult>;
+    input(input: OpensteerDomInputInput, options?: RuntimeOperationOptions): Promise<OpensteerActionResult>;
+    scroll(input: OpensteerDomScrollInput, options?: RuntimeOperationOptions): Promise<OpensteerActionResult>;
+    extract(input: OpensteerDomExtractInput, options?: RuntimeOperationOptions): Promise<OpensteerDomExtractOutput>;
+    queryNetwork(input?: OpensteerNetworkQueryInput, options?: RuntimeOperationOptions): Promise<OpensteerNetworkQueryOutput>;
+    saveNetwork(input: OpensteerNetworkSaveInput, options?: RuntimeOperationOptions): Promise<OpensteerNetworkSaveOutput>;
+    clearNetwork(input?: OpensteerNetworkClearInput, options?: RuntimeOperationOptions): Promise<OpensteerNetworkClearOutput>;
+    captureScripts(input?: OpensteerCaptureScriptsInput, options?: RuntimeOperationOptions): Promise<OpensteerCaptureScriptsOutput>;
+    minimizeNetwork(input: OpensteerNetworkMinimizeInput, options?: RuntimeOperationOptions): Promise<OpensteerNetworkMinimizeOutput>;
+    diffNetwork(input: OpensteerNetworkDiffInput, options?: RuntimeOperationOptions): Promise<OpensteerNetworkDiffOutput>;
+    readArtifact(input: OpensteerArtifactReadInput, options?: RuntimeOperationOptions): Promise<OpensteerArtifactReadOutput>;
+    probeNetwork(input: OpensteerTransportProbeInput, options?: RuntimeOperationOptions): Promise<OpensteerTransportProbeOutput>;
+    discoverReverse(input: OpensteerReverseDiscoverInput, options?: RuntimeOperationOptions): Promise<OpensteerReverseDiscoverOutput>;
+    queryReverse(input: OpensteerReverseQueryInput, options?: RuntimeOperationOptions): Promise<OpensteerReverseQueryOutput>;
+    createReversePackage(input: OpensteerReversePackageCreateInput, options?: RuntimeOperationOptions): Promise<OpensteerReversePackageCreateOutput>;
+    runReversePackage(input: OpensteerReversePackageRunInput, options?: RuntimeOperationOptions): Promise<OpensteerReversePackageRunOutput>;
+    exportReverse(input: OpensteerReverseExportInput, options?: RuntimeOperationOptions): Promise<OpensteerReverseExportOutput>;
+    getReverseReport(input: OpensteerReverseReportInput, options?: RuntimeOperationOptions): Promise<OpensteerReverseReportOutput>;
+    getReversePackage(input: OpensteerReversePackageGetInput, options?: RuntimeOperationOptions): Promise<OpensteerReversePackageGetOutput>;
+    listReversePackages(input?: OpensteerReversePackageListInput, options?: RuntimeOperationOptions): Promise<OpensteerReversePackageListOutput>;
+    patchReversePackage(input: OpensteerReversePackagePatchInput, options?: RuntimeOperationOptions): Promise<OpensteerReversePackagePatchOutput>;
+    private captureReverseCaseInternal;
+    private analyzeReverseCaseInternal;
+    private queryReverseCaseInternal;
+    private resolveReversePackageSource;
+    private replayReversePackageInternal;
+    private executeReversePackageWorkflow;
+    private executeReversePackageOperationStep;
+    private resolveReversePackageResolverValues;
+    private resolveReversePackageResolverValue;
+    private resolveReverseValueTemplate;
+    private resolveReverseValueReference;
+    private waitForReversePackageRecord;
+    private buildReverseTransportOperationInput;
+    private writePortableReverseRequestPlan;
+    private writeReversePackage;
+    private buildReversePackageDraft;
+    private writeReverseReportRecord;
+    captureInteraction(input: OpensteerInteractionCaptureInput, options?: RuntimeOperationOptions): Promise<OpensteerInteractionCaptureOutput>;
+    getInteraction(input: OpensteerInteractionGetInput, options?: RuntimeOperationOptions): Promise<OpensteerInteractionGetOutput>;
+    private runInteractionCaptureScript;
+    private runInteractionCaptureSteps;
+    diffInteraction(input: OpensteerInteractionDiffInput, options?: RuntimeOperationOptions): Promise<OpensteerInteractionDiffOutput>;
+    replayInteraction(input: OpensteerInteractionReplayInput, options?: RuntimeOperationOptions): Promise<OpensteerInteractionReplayOutput>;
+    beautifyScript(input: OpensteerScriptBeautifyInput, options?: RuntimeOperationOptions): Promise<OpensteerScriptBeautifyOutput>;
+    deobfuscateScript(input: OpensteerScriptDeobfuscateInput, options?: RuntimeOperationOptions): Promise<OpensteerScriptDeobfuscateOutput>;
+    sandboxScript(input: OpensteerScriptSandboxInput, options?: RuntimeOperationOptions): Promise<OpensteerScriptSandboxOutput>;
+    solveCaptcha(input: OpensteerCaptchaSolveInput, options?: RuntimeOperationOptions): Promise<OpensteerCaptchaSolveOutput>;
+    inferRequestPlan(input: OpensteerInferRequestPlanInput, options?: RuntimeOperationOptions): Promise<RequestPlanRecord>;
+    writeRequestPlan(input: OpensteerWriteRequestPlanInput, options?: RuntimeOperationOptions): Promise<RequestPlanRecord>;
+    getRequestPlan(input: OpensteerGetRequestPlanInput, options?: RuntimeOperationOptions): Promise<RequestPlanRecord>;
+    listRequestPlans(input?: OpensteerListRequestPlansInput, options?: RuntimeOperationOptions): Promise<OpensteerListRequestPlansOutput>;
+    writeAuthRecipe(input: OpensteerWriteAuthRecipeInput, options?: RuntimeOperationOptions): Promise<AuthRecipeRecord>;
+    writeRecipe(input: OpensteerWriteRecipeInput, options?: RuntimeOperationOptions): Promise<RecipeRecord>;
+    getAuthRecipe(input: OpensteerGetAuthRecipeInput, options?: RuntimeOperationOptions): Promise<AuthRecipeRecord>;
+    getRecipe(input: OpensteerGetRecipeInput, options?: RuntimeOperationOptions): Promise<RecipeRecord>;
+    listAuthRecipes(input?: OpensteerListAuthRecipesInput, options?: RuntimeOperationOptions): Promise<OpensteerListAuthRecipesOutput>;
+    listRecipes(input?: OpensteerListRecipesInput, options?: RuntimeOperationOptions): Promise<OpensteerListRecipesOutput>;
+    getCookies(input?: {
+        readonly urls?: readonly string[];
+    }, options?: RuntimeOperationOptions): Promise<readonly CookieRecord[]>;
+    getStorageSnapshot(input?: {
+        readonly includeSessionStorage?: boolean;
+        readonly includeIndexedDb?: boolean;
+    }, options?: RuntimeOperationOptions): Promise<StorageSnapshot>;
+    runAuthRecipe(input: OpensteerRunAuthRecipeInput, options?: RuntimeOperationOptions): Promise<OpensteerRunAuthRecipeOutput>;
+    runRecipe(input: OpensteerRunRecipeInput, options?: RuntimeOperationOptions): Promise<OpensteerRunRecipeOutput>;
+    rawRequest(input: OpensteerRawRequestInput, options?: RuntimeOperationOptions): Promise<OpensteerRawRequestOutput>;
+    route(input: OpensteerRouteOptions): Promise<OpensteerRouteRegistration>;
+    interceptScript(input: OpensteerInterceptScriptOptions): Promise<OpensteerRouteRegistration>;
+    request(input: OpensteerRequestExecuteInput, options?: RuntimeOperationOptions): Promise<OpensteerRequestExecuteOutput>;
+    computerExecute(input: OpensteerComputerExecuteInput, options?: RuntimeOperationOptions): Promise<OpensteerComputerExecuteOutput>;
+    close(options?: RuntimeOperationOptions): Promise<OpensteerSessionCloseOutput>;
+    disconnect(): Promise<void>;
+    isOpen(): boolean;
+    private runDomAction;
+    private prepareDomTarget;
+    private queryLiveNetwork;
+    private captureScriptsInternal;
+    private materializeCapturedScript;
+    private beginMutationCapture;
+    private completeMutationCapture;
+    private resolveNetworkRecordByRecordId;
+    private resolveCurrentStateSource;
+    private resolveReverseCaseById;
+    private tryResolveReverseCaseById;
+    private resolveReversePackageById;
+    private resolveReverseReportById;
+    private resolveReverseReportByPackageId;
+    private resolveReverseReportByCaseId;
+    private resolveInteractionTraceById;
+    private captureReverseStateSnapshot;
+    private restoreReverseStateSnapshots;
+    private waitForObservedReplayRecord;
+    private waitForMatchingReplayRecord;
+    private isObservedReplayRecordSettled;
+    private replayInteractionTraceById;
+    private readLiveNetworkRecords;
+    private readLiveRequestIds;
+    private observeLiveTransportDelta;
+    private executeTransportRequestWithJournal;
+    private currentBinding;
+    private requireSessionRef;
+    private ensureBrowserTransportBinding;
+    private requireExistingBrowserBindingForRecovery;
+    private executeRawTransportRequest;
+    private executeDirectTransportRequestWithPersistence;
+    private executePageHttpTransportRequestWithPersistence;
+    private executeContextTransportRequestWithPersistence;
+    private executeMatchedTlsTransportRequestWithPersistence;
+    private executePageHttpTransportRequest;
+    private executePageHttpEventStreamRequest;
+    private executePageHttpWebSocketRequest;
+    private executeContextTransportRequest;
+    private executeMatchedTlsTransportRequest;
+    private persistDirectTransportRecord;
+    private executeResolvedRequestPlan;
+    private executePlanTransportRequest;
+    private touchRequestPlanFreshness;
+    private executeConfiguredRecipeBinding;
+    private clearRecipeBindingCache;
+    private retryResolvedRequestPlan;
+    private resolveRecipeRecord;
+    private runResolvedRecipe;
+    private executeRecipeRecord;
+    private executeRecipeStep;
+    private executeAuthRecipeHook;
+    private executeRecipeRequest;
+    private resolvePageHttpBinding;
+    private syncBrowserCookiesToJar;
+    private executeAnalysisTransportRequest;
+    private resolveScriptTransformSource;
+    private buildScriptTransformOutput;
+    private applyCookieJarToTransportRequest;
+    private updateCookieJarFromResponse;
+    private readCookieValue;
+    private readStorageValue;
+    private scheduleBackgroundNetworkSaveByRequestIds;
+    private flushBackgroundNetworkPersistence;
+    private toDomTargetRef;
+    private ensureRoot;
+    private ensureEngine;
+    private ensureSemantics;
+    private ensurePageRef;
+    private requireRoot;
+    private requireEngine;
+    private requireDom;
+    private requireComputer;
+    private requireExtractionDescriptors;
+    private ensureLiveRuntimeBinding;
+    private probeRuntimeBindingHealth;
+    private readSessionState;
+    private captureSnapshotArtifacts;
+    private persistComputerArtifacts;
+    private appendTrace;
+    private cleanupSessionResources;
+    private resetRuntimeState;
+    private runWithOperationTimeout;
+    private navigatePage;
+}
+
+interface OpensteerRuntimeOperationOptions {
+    readonly signal?: AbortSignal;
+}
+interface OpensteerSemanticRuntime {
+    info(options?: OpensteerRuntimeOperationOptions): Promise<OpensteerSessionInfo>;
+    open(input?: OpensteerOpenInput, options?: OpensteerRuntimeOperationOptions): Promise<OpensteerOpenOutput>;
+    listPages(input?: OpensteerPageListInput, options?: OpensteerRuntimeOperationOptions): Promise<OpensteerPageListOutput>;
+    newPage(input?: OpensteerPageNewInput, options?: OpensteerRuntimeOperationOptions): Promise<OpensteerPageNewOutput>;
+    activatePage(input: OpensteerPageActivateInput, options?: OpensteerRuntimeOperationOptions): Promise<OpensteerPageActivateOutput>;
+    closePage(input?: OpensteerPageCloseInput, options?: OpensteerRuntimeOperationOptions): Promise<OpensteerPageCloseOutput>;
+    goto(input: OpensteerPageGotoInput, options?: OpensteerRuntimeOperationOptions): Promise<OpensteerPageGotoOutput>;
+    evaluate(input: OpensteerPageEvaluateInput, options?: OpensteerRuntimeOperationOptions): Promise<OpensteerPageEvaluateOutput>;
+    addInitScript(input: OpensteerAddInitScriptInput, options?: OpensteerRuntimeOperationOptions): Promise<OpensteerAddInitScriptOutput>;
+    snapshot(input?: OpensteerPageSnapshotInput, options?: OpensteerRuntimeOperationOptions): Promise<OpensteerPageSnapshotOutput>;
+    click(input: OpensteerDomClickInput, options?: OpensteerRuntimeOperationOptions): Promise<OpensteerActionResult>;
+    hover(input: OpensteerDomHoverInput, options?: OpensteerRuntimeOperationOptions): Promise<OpensteerActionResult>;
+    input(input: OpensteerDomInputInput, options?: OpensteerRuntimeOperationOptions): Promise<OpensteerActionResult>;
+    scroll(input: OpensteerDomScrollInput, options?: OpensteerRuntimeOperationOptions): Promise<OpensteerActionResult>;
+    extract(input: OpensteerDomExtractInput, options?: OpensteerRuntimeOperationOptions): Promise<OpensteerDomExtractOutput>;
+    queryNetwork(input?: OpensteerNetworkQueryInput, options?: OpensteerRuntimeOperationOptions): Promise<OpensteerNetworkQueryOutput>;
+    saveNetwork(input: OpensteerNetworkSaveInput, options?: OpensteerRuntimeOperationOptions): Promise<OpensteerNetworkSaveOutput>;
+    minimizeNetwork(input: OpensteerNetworkMinimizeInput, options?: OpensteerRuntimeOperationOptions): Promise<OpensteerNetworkMinimizeOutput>;
+    diffNetwork(input: OpensteerNetworkDiffInput, options?: OpensteerRuntimeOperationOptions): Promise<OpensteerNetworkDiffOutput>;
+    probeNetwork(input: OpensteerTransportProbeInput, options?: OpensteerRuntimeOperationOptions): Promise<OpensteerTransportProbeOutput>;
+    discoverReverse(input: OpensteerReverseDiscoverInput, options?: OpensteerRuntimeOperationOptions): Promise<OpensteerReverseDiscoverOutput>;
+    queryReverse(input: OpensteerReverseQueryInput, options?: OpensteerRuntimeOperationOptions): Promise<OpensteerReverseQueryOutput>;
+    createReversePackage(input: OpensteerReversePackageCreateInput, options?: OpensteerRuntimeOperationOptions): Promise<OpensteerReversePackageCreateOutput>;
+    runReversePackage(input: OpensteerReversePackageRunInput, options?: OpensteerRuntimeOperationOptions): Promise<OpensteerReversePackageRunOutput>;
+    exportReverse(input: OpensteerReverseExportInput, options?: OpensteerRuntimeOperationOptions): Promise<OpensteerReverseExportOutput>;
+    getReverseReport(input: OpensteerReverseReportInput, options?: OpensteerRuntimeOperationOptions): Promise<OpensteerReverseReportOutput>;
+    getReversePackage(input: OpensteerReversePackageGetInput, options?: OpensteerRuntimeOperationOptions): Promise<OpensteerReversePackageGetOutput>;
+    listReversePackages(input?: OpensteerReversePackageListInput, options?: OpensteerRuntimeOperationOptions): Promise<OpensteerReversePackageListOutput>;
+    patchReversePackage(input: OpensteerReversePackagePatchInput, options?: OpensteerRuntimeOperationOptions): Promise<OpensteerReversePackagePatchOutput>;
+    captureInteraction(input: OpensteerInteractionCaptureInput, options?: OpensteerRuntimeOperationOptions): Promise<OpensteerInteractionCaptureOutput>;
+    getInteraction(input: OpensteerInteractionGetInput, options?: OpensteerRuntimeOperationOptions): Promise<OpensteerInteractionGetOutput>;
+    diffInteraction(input: OpensteerInteractionDiffInput, options?: OpensteerRuntimeOperationOptions): Promise<OpensteerInteractionDiffOutput>;
+    replayInteraction(input: OpensteerInteractionReplayInput, options?: OpensteerRuntimeOperationOptions): Promise<OpensteerInteractionReplayOutput>;
+    clearNetwork(input?: OpensteerNetworkClearInput, options?: OpensteerRuntimeOperationOptions): Promise<OpensteerNetworkClearOutput>;
+    captureScripts(input?: OpensteerCaptureScriptsInput, options?: OpensteerRuntimeOperationOptions): Promise<OpensteerCaptureScriptsOutput>;
+    readArtifact(input: OpensteerArtifactReadInput, options?: OpensteerRuntimeOperationOptions): Promise<OpensteerArtifactReadOutput>;
+    beautifyScript(input: OpensteerScriptBeautifyInput, options?: OpensteerRuntimeOperationOptions): Promise<OpensteerScriptBeautifyOutput>;
+    deobfuscateScript(input: OpensteerScriptDeobfuscateInput, options?: OpensteerRuntimeOperationOptions): Promise<OpensteerScriptDeobfuscateOutput>;
+    sandboxScript(input: OpensteerScriptSandboxInput, options?: OpensteerRuntimeOperationOptions): Promise<OpensteerScriptSandboxOutput>;
+    solveCaptcha(input: OpensteerCaptchaSolveInput, options?: OpensteerRuntimeOperationOptions): Promise<OpensteerCaptchaSolveOutput>;
+    getCookies(input?: {
+        readonly urls?: readonly string[];
+    }, options?: OpensteerRuntimeOperationOptions): Promise<readonly CookieRecord[]>;
+    getStorageSnapshot(input?: {
+        readonly includeSessionStorage?: boolean;
+        readonly includeIndexedDb?: boolean;
+    }, options?: OpensteerRuntimeOperationOptions): Promise<StorageSnapshot>;
+    rawRequest(input: OpensteerRawRequestInput, options?: OpensteerRuntimeOperationOptions): Promise<OpensteerRawRequestOutput>;
+    inferRequestPlan(input: OpensteerInferRequestPlanInput, options?: OpensteerRuntimeOperationOptions): Promise<RequestPlanRecord>;
+    writeRequestPlan(input: OpensteerWriteRequestPlanInput, options?: OpensteerRuntimeOperationOptions): Promise<RequestPlanRecord>;
+    getRequestPlan(input: OpensteerGetRequestPlanInput, options?: OpensteerRuntimeOperationOptions): Promise<RequestPlanRecord>;
+    listRequestPlans(input?: OpensteerListRequestPlansInput, options?: OpensteerRuntimeOperationOptions): Promise<OpensteerListRequestPlansOutput>;
+    writeAuthRecipe(input: OpensteerWriteAuthRecipeInput, options?: OpensteerRuntimeOperationOptions): Promise<AuthRecipeRecord>;
+    writeRecipe(input: OpensteerWriteRecipeInput, options?: OpensteerRuntimeOperationOptions): Promise<RecipeRecord>;
+    getAuthRecipe(input: OpensteerGetAuthRecipeInput, options?: OpensteerRuntimeOperationOptions): Promise<AuthRecipeRecord>;
+    getRecipe(input: OpensteerGetRecipeInput, options?: OpensteerRuntimeOperationOptions): Promise<RecipeRecord>;
+    listAuthRecipes(input?: OpensteerListAuthRecipesInput, options?: OpensteerRuntimeOperationOptions): Promise<OpensteerListAuthRecipesOutput>;
+    listRecipes(input?: OpensteerListRecipesInput, options?: OpensteerRuntimeOperationOptions): Promise<OpensteerListRecipesOutput>;
+    runAuthRecipe(input: OpensteerRunAuthRecipeInput, options?: OpensteerRuntimeOperationOptions): Promise<OpensteerRunAuthRecipeOutput>;
+    runRecipe(input: OpensteerRunRecipeInput, options?: OpensteerRuntimeOperationOptions): Promise<OpensteerRunRecipeOutput>;
+    request(input: OpensteerRequestExecuteInput, options?: OpensteerRuntimeOperationOptions): Promise<OpensteerRequestExecuteOutput>;
+    computerExecute(input: OpensteerComputerExecuteInput, options?: OpensteerRuntimeOperationOptions): Promise<OpensteerComputerExecuteOutput>;
+    close(options?: OpensteerRuntimeOperationOptions): Promise<OpensteerSessionCloseOutput>;
+}
+
+declare function dispatchSemanticOperation(runtime: OpensteerSemanticRuntime, operation: OpensteerSemanticOperationName, input: unknown, options?: {
+    readonly signal?: AbortSignal;
+}): Promise<unknown>;
+
+export { type CreateFilesystemOpensteerWorkspaceOptions, type FilesystemOpensteerWorkspace, OPENSTEER_FILESYSTEM_WORKSPACE_LAYOUT, OPENSTEER_FILESYSTEM_WORKSPACE_VERSION, OPENSTEER_RUNTIME_CORE_VERSION, type OpensteerEngineFactory, type OpensteerEngineFactoryOptions, type OpensteerRuntimeOperationOptions, type OpensteerRuntimeWorkspace, type OpensteerSemanticRuntime, OpensteerSessionRuntime, type OpensteerSessionRuntimeOptions, type OpensteerWorkspaceManifest, createFilesystemOpensteerWorkspace, dispatchSemanticOperation, normalizeWorkspaceId, resolveFilesystemWorkspacePath };