@qvac/harness 1.0.0-rc.0 → 1.0.0-rc.2

package/dist-lib/lib/contract/knowledge.d.ts

@@ -0,0 +1,60 @@
+import type { AbortSignal as BareAbortSignal } from 'bare-abort-controller';
+export interface KnowledgeChunk {
+    id: string;
+    text: string;
+    metadata?: Record<string, unknown>;
+}
+export interface KnowledgeEmbedding {
+    model: string;
+    dimensions: number;
+    vectors: number[][];
+}
+export interface KnowledgeArtifact {
+    artifactId: string;
+    version?: string;
+    scope: string;
+    chunks: KnowledgeChunk[];
+    embedding?: KnowledgeEmbedding;
+}
+export interface KnowledgeUpsertResult {
+    added: number;
+    embedded: KnowledgeEmbedding | null;
+}
+export interface KnowledgeQuery {
+    text: string;
+    scopes: readonly string[];
+    k?: number;
+    signal?: BareAbortSignal;
+}
+export interface KnowledgeHit {
+    artifactId: string;
+    chunkId: string;
+    scope: string;
+    text: string;
+    score: number;
+    metadata?: Record<string, unknown>;
+}
+export interface KnowledgeArtifactStatus {
+    artifactId: string;
+    version?: string;
+    scope: string;
+    chunks: number;
+}
+export interface KnowledgeStatus {
+    model: string;
+    dimensions: number;
+    chunks: number;
+    artifacts: KnowledgeArtifactStatus[];
+}
+export interface KnowledgeGrant {
+    scopes: string[];
+}
+export interface KnowledgeRemoved {
+    removed: number;
+}
+export interface KnowledgeService {
+    upsert(artifact: KnowledgeArtifact): Promise<KnowledgeUpsertResult>;
+    remove(artifactId: string): Promise<KnowledgeRemoved>;
+    search(query: KnowledgeQuery): Promise<KnowledgeHit[]>;
+    status(): Promise<KnowledgeStatus>;
+}

package/dist-lib/lib/contract/knowledge.js

@@ -0,0 +1 @@
+export {};

package/dist-lib/lib/contract/models.d.ts

@@ -0,0 +1,56 @@
+import type { createVectorIndex, loadVectorIndex } from '@qvac/sdk';
+import type { AbortSignal as BareAbortSignal } from 'bare-abort-controller';
+import type { ModelSrc } from '../models/context.ts';
+import type { CancelSdk, ModelState, TrackedLoad } from '../models/model-pool.ts';
+export type { CancelSdk, ModelState, TrackedLoad };
+export interface ModelHost {
+    sdk(): Promise<unknown>;
+    track(load: TrackedLoad, sdk?: Partial<CancelSdk>): TrackedLoad;
+    makeRoom(signal: BareAbortSignal | undefined, busyMessage: string): Promise<void>;
+    completionModel(model: string, signal?: BareAbortSignal): Promise<BorrowedModel>;
+    emit(state: ModelState): void;
+    progressState(model: string, progress: Record<string, unknown>): ModelState;
+    statusChanged(): void;
+    readonly transcriptionDevice?: 'cpu' | 'gpu' | undefined;
+    registerPool(spec: ResidentPoolSpec): ResidentPool;
+    enterWork(): () => void;
+}
+export interface BorrowedModel {
+    modelId: string;
+    release(): void;
+}
+export interface ResidentPoolSpec {
+    addon: 'tts' | 'parakeet';
+    modelType: string;
+    modelConfig?: Record<string, unknown>;
+    modelConfigFor?: (modelSrc: ModelSrc) => Readonly<Record<string, unknown>> | undefined;
+    openclCache?: boolean;
+    label?: string;
+    needsRoom?: (model: string) => boolean;
+    sdk(): Promise<unknown>;
+}
+export interface PooledModel {
+    load(): Promise<{
+        modelId: string;
+    }>;
+    peek(): Promise<unknown> | null;
+    release(): void;
+}
+export interface ResidentPool {
+    open(model: string): PooledModel;
+    resident(model: string): boolean;
+    evictIdle(wanted: (model: string) => boolean): Promise<void>;
+}
+export interface EmbedRequest {
+    model: string;
+    texts: string[];
+    signal?: BareAbortSignal;
+}
+export interface VectorIndexSdk {
+    createVectorIndex: typeof createVectorIndex;
+    loadVectorIndex: typeof loadVectorIndex;
+}
+export interface EmbedHost {
+    embed(request: EmbedRequest): Promise<number[][]>;
+    sdk(): Promise<VectorIndexSdk>;
+}

package/dist-lib/lib/contract/models.js

@@ -0,0 +1 @@
+export {};

package/dist-lib/lib/contract/run.d.ts

@@ -0,0 +1,142 @@
+export interface RunBudget {
+    readonly deadlineMs: number;
+    outputBytesUsed: number;
+}
+export interface HistoryToolCall {
+    id: string;
+    name: string;
+    arguments: Record<string, unknown>;
+}
+export interface Message {
+    role: string;
+    content: string;
+    attachments?: {
+        path: string;
+    }[];
+    toolCalls?: HistoryToolCall[] | null;
+    toolCallId?: string | null;
+    name?: string | null;
+    id?: string | null;
+    [key: string]: unknown;
+}
+export interface FailureResultReference {
+    type: 'qvac-failure-result-ref';
+    ref: string;
+    callId: string;
+    compactedTo?: number;
+}
+export type CompletionHistoryEntry = Message | FailureResultReference;
+export interface HistorySplice {
+    at: number;
+    messages: CompletionHistoryEntry[];
+}
+export interface RunBackendUse {
+    tool: string;
+    requestedGpu: boolean;
+    device: 'gpu' | 'cpu' | 'unknown';
+    backend: string;
+}
+export interface PlanStep {
+    step: string;
+    status: 'pending' | 'in_progress' | 'done';
+}
+export type GoalStatus = 'open' | 'met' | 'rounds' | 'time' | 'tokens';
+export interface RunGoal {
+    objective: string;
+    rounds?: number;
+    ms?: number;
+    tokens?: number;
+}
+export type ToolEffect = 'read' | 'write';
+export type ToolDecision = 'auto' | 'allowed' | 'denied' | 'skip-all' | 'blocked';
+export interface ResourceDescriptor {
+    kind: string;
+    label: string;
+}
+export interface ToolActivityEvent {
+    type: 'tool-activity';
+    name: string;
+    args: Record<string, unknown>;
+    resource: ResourceDescriptor | null;
+    effect: ToolEffect;
+    decision: ToolDecision;
+}
+export type RunOutcome = 'answered' | 'mute' | 'exhausted' | 'search-capped' | 'time-capped' | 'tool-ended' | 'delivered';
+export interface ToolCallDisplay {
+    readonly label: string;
+    readonly description?: string;
+    readonly iconEmoji?: string;
+}
+export type ToolExecutionOutcome = {
+    readonly kind: 'success';
+} | {
+    readonly kind: 'error';
+    readonly message?: string;
+    readonly error?: unknown;
+} | {
+    readonly kind: 'denied';
+    readonly reason?: string;
+} | {
+    readonly kind: 'blocked';
+    readonly reason?: string;
+} | {
+    readonly kind: 'guidance';
+    readonly message: string;
+};
+export interface HookRejection {
+    kind: 'hook-rejection';
+    hook: string;
+    phase: 'preToolCall' | 'postToolCall' | 'runStart' | 'runEnd' | 'runPause' | 'runResume' | 'promptSubmit' | 'toolFailure' | 'stop' | 'preFold';
+    error: string;
+    guidance: true;
+}
+export type TrustedOrigin = 'user' | 'tool-result' | 'skill';
+export interface TrustedSource {
+    origin: TrustedOrigin;
+    text: string;
+}
+export interface TrustedSourceFacts {
+    origin: Exclude<TrustedOrigin, 'user'>;
+    addresses: string[];
+    refused: boolean;
+}
+export interface Operation {
+    id: string;
+    name: string;
+    args: unknown;
+    effect: 'read' | 'write';
+    reason?: string;
+}
+export type RunLifecycleEvent = {
+    type: 'run-started';
+    runId: string;
+    parentRunId?: string;
+} | {
+    type: 'run-resumed' | 'paused';
+    runId: string;
+} | {
+    type: 'round-reset';
+    runId: string;
+    round: number;
+    replacedTypes?: ('content' | 'thinking')[];
+} | {
+    type: 'recovery-required';
+    runId: string;
+    operation: Operation;
+};
+export interface RoundSpeed {
+    round: number;
+    durationMs: number;
+    promptTokens?: number;
+    cacheTokens?: number;
+    generatedTokens?: number;
+    promptTokensPerSecond?: number;
+    tokensPerSecond?: number;
+    timeToFirstToken?: number;
+    stopReason?: string;
+}
+export interface ToolSpeed {
+    round: number;
+    name: string;
+    durationMs: number;
+}

package/dist-lib/lib/contract/run.js

@@ -0,0 +1 @@
+export {};

package/dist-lib/lib/contract/sandbox.d.ts

@@ -0,0 +1,29 @@
+import type { AbortSignal as BareAbortSignal } from 'bare-abort-controller';
+export interface SandboxExecOptions {
+    cwd?: string;
+    env?: Record<string, string>;
+    timeoutMs?: number;
+    signal?: BareAbortSignal;
+}
+export interface SandboxExecResult {
+    stdout: string;
+    stderr: string;
+    exitCode: number;
+}
+export interface SandboxStartOptions {
+    cwd?: string;
+}
+export interface SandboxJob {
+    readonly exited: Promise<number>;
+    stop(): Promise<void>;
+}
+export interface SandboxWorkspace {
+    exec(command: string, options?: SandboxExecOptions): Promise<SandboxExecResult>;
+    start(command: string, options?: SandboxStartOptions): Promise<SandboxJob>;
+    close(): Promise<void>;
+}
+export interface SandboxService {
+    readonly name: string;
+    readonly isolated: boolean;
+    open(workspaceDir: string): Promise<SandboxWorkspace>;
+}

package/dist-lib/lib/contract/sandbox.js

@@ -0,0 +1 @@
+export {};

package/dist-lib/lib/contract/skill-readiness.d.ts

@@ -0,0 +1,14 @@
+import type { CredentialStoreFn } from '../tools/skills/auth-resolver.ts';
+import type { SkillState } from '../tools/skills/skill-state-constants.ts';
+export interface SkillReadinessContext {
+    readonly platform: string | undefined;
+    readonly agentId: string | null | undefined;
+    readonly credentialStore: CredentialStoreFn | undefined;
+    readonly missingBins: readonly string[];
+}
+export interface SkillReadiness {
+    readonly skill: string;
+    state(ctx: SkillReadinessContext): Promise<SkillState | null> | SkillState | null;
+    readonly probeVersions?: false;
+    readonly deviceSharedKeys?: readonly string[];
+}

package/dist-lib/lib/contract/skill-readiness.js

@@ -0,0 +1 @@
+export {};

package/dist-lib/lib/{capabilities/voice.d.ts → contract/speech.d.ts}

@@ -1,6 +1,6 @@
 import type { TextToSpeechStreamClientParams, TextToSpeechStreamSession } from '@qvac/sdk';
 import type { AbortSignal as BareAbortSignal } from 'bare-abort-controller';
-export declare const SUPERTONIC_SAMPLE_RATE = 44100;
+import type { CapabilityProfile } from '../models/model-catalog-constants.ts';
 export type TtsStreamSession = TextToSpeechStreamSession;
 export interface TranscribeStreamSegment {
     text: string;
@@ -42,6 +42,7 @@ export interface VoiceSdk {
         bufferStream: AsyncGenerator<number>;
         buffer: Promise<number[]>;
         done: Promise<boolean>;
+        sampleRate: Promise<number | undefined>;
     };
     textToSpeechStream(params: TextToSpeechStreamClientParams): Promise<TtsStreamSession>;
     cancel(params: {
@@ -59,24 +60,18 @@ export interface SpeakContext {
     text: string;
     signal?: BareAbortSignal;
 }
-export interface SpeakResult {
-    audio: Buffer;
-    sampleRate: number;
-}
 export interface SpeakStreamContext {
     model: string;
     text: AsyncIterable<string>;
     signal?: BareAbortSignal;
 }
-export type VoiceLane = <T>(job: () => Promise<T>) => Promise<T>;
-export declare function createVoiceLane(): VoiceLane;
-export declare function transcribeOnce(sdk: VoiceSdk, modelId: string, audio: Buffer): Promise<string>;
-export interface TranscribeStreamingOptions {
-    modelId: string;
-    signal?: BareAbortSignal | undefined;
+export interface SpeakResult {
+    audio: Buffer;
+    sampleRate: number;
+}
+export interface SpeechService {
+    defaultModel(profile: CapabilityProfile | null): string;
+    transcribe(context: TranscribeContext): Promise<string>;
+    speak(context: SpeakContext): Promise<SpeakResult>;
+    speakStream(context: SpeakStreamContext): AsyncIterable<SpeakResult>;
 }
-export declare function transcribeStreaming(sdk: VoiceSdk, pcm: Uint8Array, { modelId, signal }: TranscribeStreamingOptions): Promise<string>;
-export declare function speakStreamOnce(sdk: VoiceSdk, modelId: string, text: AsyncIterable<string>): AsyncGenerator<SpeakResult>;
-export declare function speakable(text: string): string;
-export declare function speakOnce(sdk: VoiceSdk, modelId: string, text: string): Promise<number[]>;
-export declare function packSamples(samples: number[]): Buffer;

package/dist-lib/lib/contract/speech.js

@@ -0,0 +1 @@
+export {};

package/dist-lib/lib/contract-types.d.ts

@@ -1,5 +1,5 @@
 import type { HarnessCapabilityProfile } from '../spec/hyperschema/types.d.ts';
-import type { ApproveFn, AskUserFn, AttachFn, FetchAttachmentFn, ProgressFn, RagSearchFn, ResourceDescriptor, ResponseFormat } from './capabilities/completion.ts';
+import type { AgentHandoff, ApproveFn, AskUserFn, AttachFn, FetchAttachmentFn, HistoryToolCall, ProgressFn, ResourceDescriptor, ResponseFormat } from './contract/index.ts';
 import type { KvCacheDeletionResult } from './capabilities/kv-cache.ts';
 import type { ModelSourcePreview, PreviewModelSourceContext } from './capabilities/preview-model-source.ts';
 import type { MemoryBudget } from './hardware/memory-budget.ts';
@@ -11,11 +11,15 @@ import type { ListModelsOptions, ModelInfo } from './models/model-list.ts';
 import type { ToolCatalogEntry } from './tools/catalog.ts';
 import type { ManagedSkill, SkillFileContent } from './tools/skills/overlay-crud.ts';
 import type { DriveOpFn, GrantedDrive } from './tools/fs/remote.ts';
+import type { SpeakResult } from './contract/speech.ts';
+import type { RunInput } from './contract/completion.ts';
+import type { RunGoal } from './contract/run.ts';
+import type { KnowledgeArtifact, KnowledgeGrant, KnowledgeHit, KnowledgeQuery, KnowledgeRemoved, KnowledgeStatus, KnowledgeUpsertResult } from './contract/knowledge.ts';
 import type { ResolvedSkillCatalogEntry } from './tools/skills/catalog.ts';
 import type { InstallStep, SkillSetup } from './tools/skills/manifest.ts';
-import type { EngineBoot, EngineStep, HostRunLog, HostRunLogLease, RecoveryResolution, RunRecord } from './run-log-protocol.ts';
+import type { EngineBoot, EngineStep, HostRunLog, HostRunLogLease, RecoveryResolution, RunRecord } from './run-log/index.ts';
 export type { InstallStep, ListModelsOptions, ModelInfo, ResolvedSkillCatalogEntry, ResourceDescriptor, RunRecord, SkillSetup, ToolCatalogEntry };
-export type { HostRunLog, HostRunLogLease };
+export type { HostRunLog, HostRunLogLease, SpeakResult };
 export type ApprovalCall = Parameters<ApproveFn>[0];
 export interface ChatMessage {
     role: 'system' | 'user' | 'assistant' | 'tool';
@@ -23,6 +27,10 @@ export interface ChatMessage {
     attachments?: {
         path: string;
     }[] | null;
+    toolCalls?: HistoryToolCall[] | null;
+    toolCallId?: string | null;
+    name?: string | null;
+    id?: string | null;
 }
 export interface AgentKnobs {
     id?: string;
@@ -43,13 +51,18 @@ export interface AgentKnobs {
     approvalMode?: 'ask' | 'skip-all' | null;
     disabledToolsets?: string[] | null;
     sandboxMode?: boolean | null;
+    handoffs?: AgentHandoff[] | null;
+    plan?: boolean | null;
+    model?: string | null;
 }
 export interface CompletionContext {
     runId?: string;
+    parentRunId?: string;
     resume?: boolean;
     recovery?: RecoveryResolution[];
     model: string;
     agent: AgentKnobs;
+    agents?: Record<string, AgentKnobs>;
     messages: ChatMessage[];
     cacheKey?: string;
     thinkingDefault?: string;
@@ -57,6 +70,10 @@ export interface CompletionContext {
     generationParams?: LlmGenerationParams;
     responseFormat?: ResponseFormat;
     captureInferenceCalls?: boolean;
+    maxToolRounds?: number;
+    knowledge?: KnowledgeGrant;
+    planMode?: boolean;
+    goal?: RunGoal;
     grantedDirs?: string[];
     grantedDrives?: GrantedDrive[];
     driveOp?: DriveOpFn;
@@ -64,7 +81,6 @@ export interface CompletionContext {
     approve?: (call: ApprovalCall) => Promise<boolean>;
     attach?: AttachFn;
     fetchAttachment?: FetchAttachmentFn;
-    ragSearch?: RagSearchFn;
     progress?: ProgressFn;
     askUser?: AskUserFn;
     runLog?: HostRunLog;
@@ -79,6 +95,7 @@ export interface CompletionContext {
         }) => void;
         removeEventListener?: (type: 'abort', fn: () => void) => void;
     };
+    input?: AsyncIterable<RunInput>;
 }
 export type ResumeCompletionContext = Omit<Partial<CompletionContext>, 'runId' | 'resume'> & {
     runId: string;
@@ -109,6 +126,22 @@ export interface HarnessEvent {
     message?: string;
     [key: string]: unknown;
 }
+export interface LoadFit {
+    verdict: 'fit' | 'does-not-fit' | 'unknown';
+    reason: string;
+    plan?: {
+        nCtx: number;
+        nGpuLayers: number;
+        nGpuDevices: number;
+    } | undefined;
+    deviceBytes?: number | undefined;
+    hostBytes?: number | undefined;
+}
+export interface LoadedModel {
+    model: string;
+    refs: number;
+    fit?: LoadFit;
+}
 export interface ModelState {
     status: string;
     model?: string;
@@ -117,10 +150,7 @@ export interface ModelState {
     total?: number;
     message?: string;
     catalogChanged?: boolean;
-    loaded?: Array<{
-        model: string;
-        refs: number;
-    }>;
+    loaded?: LoadedModel[];
 }
 export interface WarmModelContext {
     model: string;
@@ -159,20 +189,13 @@ export interface SpeakContext {
     text: string;
     signal?: CompletionContext['signal'];
 }
-export interface SpeakResult {
-    audio: Buffer;
-    sampleRate: number;
-}
 export interface SpeakStreamContext {
     model: string;
     text: AsyncIterable<string>;
     signal?: CompletionContext['signal'];
 }
 export interface HarnessDiagnostics {
-    models: Array<{
-        model: string;
-        refs: number;
-    }>;
+    models: LoadedModel[];
     suspended: boolean;
     sdkLoaded: boolean;
     toolNames: string[];
@@ -263,6 +286,10 @@ export interface HarnessContract {
     previewModelSource?(context: PreviewModelSourceContext): Promise<ModelSourcePreview>;
     capability?(): Promise<CapabilityInfo>;
     diagnostics?(): HarnessDiagnostics;
+    knowledgeUpsert?(artifact: KnowledgeArtifact): Promise<KnowledgeUpsertResult>;
+    knowledgeRemove?(artifactId: string): Promise<KnowledgeRemoved>;
+    knowledgeSearch?(query: Omit<KnowledgeQuery, 'signal'>): Promise<KnowledgeHit[]>;
+    knowledgeStatus?(): Promise<KnowledgeStatus>;
 }
 export interface HarnessStatus {
     state: 'running' | 'died';

package/dist-lib/lib/docx/index.d.ts

@@ -1,5 +1,4 @@
 import type { AbortSignal } from 'bare-abort-controller';
-export { closePythonWorker as closeDocxWorker } from '../tools/exec/adapters/python/worker/active.ts';
 export interface DocxExtractOptions {
     readonly signal?: AbortSignal;
 }

package/dist-lib/lib/docx/index.js

@@ -1,26 +1,17 @@
-import { extractWithPython } from '../office/python.js';
-export { closePythonWorker as closeDocxWorker } from '../tools/exec/adapters/python/worker/active.js';
-const PACKAGES = ['python-docx==1.2.0'];
-const EXTRACT = `from docx import Document
-from docx.text.paragraph import Paragraph
-from pathlib import Path
-
-def text(container):
-    for block in container.iter_inner_content():
-        if isinstance(block, Paragraph):
-            if block.text.strip():
-                yield block.text
-        else:
-            for row in block.rows:
-                yield " | ".join(" ".join(text(cell)) for cell in row.cells)
-
-Path("extracted.txt").write_text("\\n".join(text(Document("input.docx"))), encoding="utf-8")
-`;
+import { docx } from '../office/engine/index.js';
+import { cellText, extractWith } from '../office/extract.js';
+function documentText(bytes) {
+    const lines = [];
+    for (const block of docx.open(bytes).read().blocks) {
+        if (block.type === 'table') {
+            lines.push(...block.rows.map((row) => row.map(cellText).join(' | ')));
+        }
+        else if (block.type === 'paragraph' && block.text.trim()) {
+            lines.push(block.text);
+        }
+    }
+    return lines.join('\n');
+}
 export async function extractDocxText(bytes, fileName, options = {}) {
-    return extractWithPython(bytes, fileName, {
-        format: 'DOCX',
-        packages: PACKAGES,
-        source: EXTRACT,
-        signal: options.signal
-    });
+    return extractWith(bytes, { fileName, signal: options.signal, extract: documentText });
 }

package/dist-lib/lib/embeddings/index.d.ts

@@ -0,0 +1,63 @@
+import { type EmbedContext } from '../capabilities/embed.ts';
+import type { Lifecycle } from '../lifecycle/index.ts';
+import { type EmbedDevice } from '../models/embed-config.ts';
+import { type FitAssessment, type FitQuery } from '../models/model-fit.ts';
+import { createEmbedPool, type LoadTracker, type ModelState } from '../models/model-pool.ts';
+import type { SdkLoader } from '../sdk-loader.ts';
+export type EmbedPool = ReturnType<typeof createEmbedPool>;
+export type EmbeddingsGate = Pick<Lifecycle, 'suspended' | 'opened' | 'ready' | 'enterWork' | 'assertNotClosing' | 'recordPoolCleanupFailure' | 'recordModelUnloadFailure'>;
+export interface EmbeddingsOptions {
+    device?: EmbedDevice | undefined;
+    gpuLayers?: number | undefined;
+    batchSize?: number | undefined;
+    sdk: Pick<SdkLoader, 'loadEmbed'>;
+    loads: LoadTracker;
+    gate: EmbeddingsGate;
+    notify(state: ModelState): void;
+    settleFit(query: FitQuery): Promise<FitAssessment | null>;
+    evictIdleChat(): Promise<void>;
+}
+export interface EmbedTarget {
+    readonly pool: EmbedPool;
+    readonly key: string;
+    open(): ReturnType<EmbedPool['open']>;
+}
+export interface RoomTarget {
+    readonly pool: unknown;
+    readonly key: string;
+}
+export declare class Embeddings {
+    private readonly _sdk;
+    private readonly _loads;
+    private readonly _gate;
+    private readonly _notify;
+    private readonly _settleFit;
+    private readonly _evictIdleChat;
+    private _embedModels;
+    private readonly _retiredEmbedModels;
+    private readonly _faultedEmbedKeys;
+    private readonly _embedLane;
+    private _embedFaults;
+    private readonly _embedGpuLayers?;
+    private readonly _embedBatchSize;
+    private _embedControl;
+    constructor(opts: EmbeddingsOptions);
+    get pool(): EmbedPool;
+    get device(): EmbedDevice;
+    pools(): EmbedPool[];
+    target(model: string): EmbedTarget;
+    recreate(): void;
+    evictIdle(): Array<Promise<unknown>>;
+    setDevice(device: EmbedDevice): Promise<void>;
+    makeRoom(model: string, { pool, key }: RoomTarget): Promise<void>;
+    destroy(): Promise<void>;
+    embed({ model, texts, signal }: EmbedContext): Promise<number[][]>;
+    private _createEmbedPool;
+    private _collectRetiredEmbedPool;
+    private _releaseEmbedResource;
+    private _releaseEmbedResourceBeforeWork;
+    private _markEmbedFault;
+    private _releaseEmbedResourceAfter;
+    private _enqueueEmbedControl;
+    private _setEmbeddingDevice;
+}