@poe-platform/safe-js 0.1.0

package/dist/config-mutations/types.d.ts

@@ -0,0 +1,168 @@
+export type ConfigPrimitive = string | number | boolean | null;
+export type ConfigValue = ConfigPrimitive | ConfigObject | ConfigArray | Date;
+export interface ConfigObject {
+    [key: string]: ConfigValue;
+}
+export type ConfigArray = ConfigValue[];
+export declare function isConfigObject(value: unknown): value is ConfigObject;
+export interface FileSystem {
+    readFile(path: string, encoding: "utf8"): Promise<string>;
+    writeFile(path: string, content: string, options?: {
+        encoding: "utf8";
+        flag?: string;
+    }): Promise<void>;
+    mkdir(path: string, options?: {
+        recursive: boolean;
+    }): Promise<void>;
+    rename(oldPath: string, newPath: string): Promise<void>;
+    unlink(path: string): Promise<void>;
+    rm?(path: string, options?: {
+        recursive?: boolean;
+        force?: boolean;
+    }): Promise<void>;
+    stat(path: string): Promise<{
+        mode?: number;
+    }>;
+    lstat(path: string): Promise<{
+        isSymbolicLink(): boolean;
+    }>;
+    readdir(path: string): Promise<string[]>;
+    chmod?(path: string, mode: number): Promise<void>;
+}
+export type TemplateLoader = (templateId: string) => Promise<string>;
+export interface ConfigFormat {
+    /** Parse string content into object */
+    parse(content: string): ConfigObject;
+    /** Serialize object to string (with consistent formatting) */
+    serialize(obj: ConfigObject): string;
+    /** Serialize an update against original content while preserving comments when possible */
+    serializeUpdate?(content: string, current: ConfigObject, next: ConfigObject): string;
+    /** Deep merge patch into base, returning new object */
+    merge(base: ConfigObject, patch: ConfigObject): ConfigObject;
+    /** Remove keys matching shape from object, returning new object */
+    prune(obj: ConfigObject, shape: ConfigObject): {
+        changed: boolean;
+        result: ConfigObject;
+    };
+}
+export interface PathMapper {
+    /** Map a target directory to a different location (e.g., for isolated configs) */
+    mapTargetDirectory(input: {
+        targetDirectory: string;
+    }): string;
+}
+export interface MutationContext {
+    /** Filesystem interface - required */
+    fs: FileSystem;
+    /** Home directory for ~ expansion - required */
+    homeDir: string;
+    /** Optional dry-run mode */
+    dryRun?: boolean;
+    /** Optional observers for logging */
+    observers?: MutationObservers;
+    /** Required for template mutations */
+    templates?: TemplateLoader;
+    /** Optional path mapper for redirecting paths (used for isolated configs) */
+    pathMapper?: PathMapper;
+}
+export interface MutationOptions {
+    [key: string]: unknown;
+}
+export type ValueResolver<T> = T | ((ctx: MutationOptions) => T);
+interface BaseMutation {
+    /** Human-readable label for logging */
+    label?: string;
+}
+export interface ConfigMergeMutation extends BaseMutation {
+    kind: "configMerge";
+    target: ValueResolver<string>;
+    value: ValueResolver<ConfigObject>;
+    format?: "json" | "toml" | "yaml";
+    pruneByPrefix?: Record<string, string>;
+}
+export interface ConfigPruneMutation extends BaseMutation {
+    kind: "configPrune";
+    target: ValueResolver<string>;
+    shape: ValueResolver<ConfigObject>;
+    format?: "json" | "toml" | "yaml";
+    onlyIf?: (doc: ConfigObject, ctx: MutationOptions) => boolean;
+}
+export interface ConfigTransformMutation extends BaseMutation {
+    kind: "configTransform";
+    target: ValueResolver<string>;
+    format?: "json" | "toml" | "yaml";
+    transform: (content: ConfigObject, ctx: MutationOptions) => {
+        content: ConfigObject | null;
+        changed: boolean;
+    };
+}
+export interface EnsureDirectoryMutation extends BaseMutation {
+    kind: "ensureDirectory";
+    path: ValueResolver<string>;
+}
+export interface RemoveDirectoryMutation extends BaseMutation {
+    kind: "removeDirectory";
+    path: ValueResolver<string>;
+    force?: boolean;
+}
+export interface RemoveFileMutation extends BaseMutation {
+    kind: "removeFile";
+    target: ValueResolver<string>;
+    whenEmpty?: boolean;
+    whenContentMatches?: RegExp;
+}
+export interface ChmodMutation extends BaseMutation {
+    kind: "chmod";
+    target: ValueResolver<string>;
+    mode: number;
+}
+export interface BackupMutation extends BaseMutation {
+    kind: "backup";
+    target: ValueResolver<string>;
+    once?: boolean;
+}
+export interface RestoreBackupMutation extends BaseMutation {
+    kind: "restoreBackup";
+    target: ValueResolver<string>;
+}
+export interface TemplateWriteMutation extends BaseMutation {
+    kind: "templateWrite";
+    target: ValueResolver<string>;
+    templateId: string;
+    context?: ValueResolver<ConfigObject>;
+}
+export interface TemplateMergeTomlMutation extends BaseMutation {
+    kind: "templateMergeToml";
+    target: ValueResolver<string>;
+    templateId: string;
+    context?: ValueResolver<ConfigObject>;
+}
+export interface TemplateMergeJsonMutation extends BaseMutation {
+    kind: "templateMergeJson";
+    target: ValueResolver<string>;
+    templateId: string;
+    context?: ValueResolver<ConfigObject>;
+}
+export type Mutation = ConfigMergeMutation | ConfigPruneMutation | ConfigTransformMutation | EnsureDirectoryMutation | RemoveDirectoryMutation | RemoveFileMutation | ChmodMutation | BackupMutation | RestoreBackupMutation | TemplateWriteMutation | TemplateMergeTomlMutation | TemplateMergeJsonMutation;
+export type MutationEffect = "none" | "mkdir" | "write" | "delete" | "chmod" | "copy";
+export type MutationDetail = "create" | "update" | "delete" | "noop" | "backup" | "restore";
+export interface MutationOutcome {
+    changed: boolean;
+    effect: MutationEffect;
+    detail?: MutationDetail;
+}
+export interface MutationDetails {
+    kind: string;
+    label: string;
+    targetPath?: string;
+}
+export interface MutationObservers {
+    onStart?(details: MutationDetails): void;
+    onComplete?(details: MutationDetails, outcome: MutationOutcome): void;
+    onError?(details: MutationDetails, error: unknown): void;
+}
+export interface MutationResult {
+    changed: boolean;
+    effects: MutationOutcome[];
+}
+export {};

package/dist/poe-code-config/compile/schema-compiler.d.ts

@@ -0,0 +1,11 @@
+import type { JsonSchemaDocument, JsonSchemaDocumentOptions } from "../../toolcraft-schema/index.js";
+interface CompileConfigSchemaOptions {
+    entrypoints: readonly string[];
+    document?: JsonSchemaDocumentOptions;
+}
+export interface CompileConfigSchemaFromSourceTextsOptions extends CompileConfigSchemaOptions {
+    files: Record<string, string>;
+}
+export declare function compileConfigSchemaFromEntrypoints(options: CompileConfigSchemaOptions): JsonSchemaDocument;
+export declare function compileConfigSchemaFromSourceTexts(options: CompileConfigSchemaFromSourceTextsOptions): JsonSchemaDocument;
+export {};

package/dist/poe-code-config/config.d.ts

@@ -0,0 +1,2 @@
+import type { ConfigStore, ConfigStoreOptions } from "./types.js";
+export declare function createConfigStore(options: ConfigStoreOptions): ConfigStore;

package/dist/poe-code-config/configured-services.d.ts

@@ -0,0 +1,29 @@
+import { type FileSystem } from "../config-mutations/index.js";
+import { ProviderRegistry, type ApiShapeId } from "../providers/index.js";
+export interface ConfigStoreOptions {
+    fs: FileSystem;
+    filePath: string;
+    projectFilePath?: string;
+    providerRegistry?: Pick<ProviderRegistry, "get">;
+    warn?: (message: string) => void;
+    readOnly?: boolean;
+}
+export interface ConfiguredServiceMetadata {
+    provider: string;
+    apiShape?: ApiShapeId;
+    files: string[];
+    model?: string;
+    reasoningEffort?: string;
+    baseUrl?: string;
+    shapeBaseUrl?: string[];
+}
+export interface SaveConfiguredServiceOptions extends ConfigStoreOptions {
+    service: string;
+    metadata: ConfiguredServiceMetadata;
+}
+export interface UnconfigureServiceOptions extends ConfigStoreOptions {
+    service: string;
+}
+export declare function loadConfiguredServices(options: ConfigStoreOptions): Promise<Record<string, ConfiguredServiceMetadata>>;
+export declare function saveConfiguredService(options: SaveConfiguredServiceOptions): Promise<void>;
+export declare function unconfigureService(options: UnconfigureServiceOptions): Promise<boolean>;

package/dist/poe-code-config/index.d.ts

@@ -0,0 +1,16 @@
+export type { ConfigDocument, ConfigFieldType, ConfigStore, ConfigStoreOptions, BraintrustIntegrationConfig, InferConfig, IntegrationsConfig, MemoryCacheConfig, MemoryConfidenceConfig, MemoryConfig, MemoryMcpConfig, MemoryQueryConfig, ResolvedConfig, SchemaField, ScopeDefinition, ScopedConfig, ScopeSchema, TypeMap } from "./types.js";
+export { defineScope, integrationsConfigScope } from "./schema.js";
+export { compileConfigSchemaFromEntrypoints, compileConfigSchemaFromSourceTexts, type CompileConfigSchemaFromSourceTextsOptions } from "./compile/schema-compiler.js";
+export { parseRunner, parseRuntime, resolveRuntime, runtimeConfigScope, type DockerRuntime, type HostRuntime, type RunnerScope, type RuntimeConfig, type RuntimeMount, type RuntimeResolveResult, type RuntimeRunner } from "./runtime.js";
+export { planConfigScope } from "./plan-scope.js";
+export { createConfigStore } from "./config.js";
+export { deepMergeDocuments } from "./merge.js";
+export { readMergedDocumentReadonly } from "./store.js";
+export { mergeExperimentCallbacks, mergeLoopCallbacks, mergePipelineCallbacks, type ExperimentCallbackFields, type LoopCallbacks, type PipelineCallbackFields } from "./merge-callbacks.js";
+export { cacheEnabled, configuredMemoryRoot, configuredTimeout, defaultQueryBudget, DEFAULT_QUERY_BUDGET_TOKENS, mcpWritesAllowed, resolveAgent, type MemoryConfigOptions } from "./memory.js";
+export { resolveScope } from "./resolve.js";
+export { collectEnvOverrides, initProjectConfig, resolveEditTarget, type EditTargetOptions, type EnvOverrides } from "./inspect.js";
+export { readDocument, readDocumentReadonly, readMergedDocument, resolveConfigPath, resolveServicesConfigPath, resolveProjectConfigPath, writeDocument, writeScope } from "./store.js";
+export { loadProviderShapeBaseUrls, saveProviderShapeBaseUrls, type LoadProviderShapeBaseUrlsOptions, type ProviderConfigStoreOptions, type SaveProviderShapeBaseUrlsOptions } from "./provider-config.js";
+export { loadConfiguredServices, saveConfiguredService, unconfigureService, type ConfiguredServiceMetadata, type SaveConfiguredServiceOptions, type UnconfigureServiceOptions } from "./configured-services.js";
+export { createStateManager, loadStateManager, type JobEntry, type JobListFilter, type JobRegistry, type JobStatus, type StateManager, type TemplateBackend, type TemplateEntry, type TemplateRegistry } from "./state/index.js";

package/dist/poe-code-config/inspect.d.ts

@@ -0,0 +1,13 @@
+import { type FileSystem } from "../config-mutations/index.js";
+import type { ConfigDocument, ScopeDefinition, ScopeSchema } from "./types.js";
+export interface EnvOverrides {
+    entries: string[];
+    document: ConfigDocument;
+}
+export interface EditTargetOptions {
+    global?: boolean;
+    project?: boolean;
+}
+export declare function collectEnvOverrides(scopes: ReadonlyArray<ScopeDefinition<ScopeSchema>>, env: Record<string, string | undefined>): EnvOverrides;
+export declare function resolveEditTarget(fs: FileSystem, configPath: string, projectConfigPath: string, options: EditTargetOptions): Promise<string>;
+export declare function initProjectConfig(fs: FileSystem, targetPath: string): Promise<"created" | "already-exists">;

package/dist/poe-code-config/memory.d.ts

@@ -0,0 +1,14 @@
+import type { FileSystem } from "../config-mutations/index.js";
+/** Memory context budget used when memory.query.defaultBudgetTokens is unset. */
+export declare const DEFAULT_QUERY_BUDGET_TOKENS = 4096;
+export interface MemoryConfigOptions {
+    fs: FileSystem;
+    filePath: string;
+    projectFilePath?: string;
+}
+export declare function configuredMemoryRoot(options: MemoryConfigOptions): Promise<string | undefined>;
+export declare function resolveAgent(options: MemoryConfigOptions, fallbackAgent: string | null): Promise<string | null>;
+export declare function configuredTimeout(options: MemoryConfigOptions): Promise<number>;
+export declare function cacheEnabled(options: MemoryConfigOptions): Promise<boolean>;
+export declare function mcpWritesAllowed(options: MemoryConfigOptions): Promise<boolean>;
+export declare function defaultQueryBudget(options: MemoryConfigOptions): Promise<number>;

package/dist/poe-code-config/merge-callbacks.d.ts

@@ -0,0 +1,38 @@
+type BivariantCallback<Args extends unknown[], Return = void> = {
+    callback(...args: Args): Return;
+}["callback"];
+export type PipelineCallbackFields = {
+    onPlanResolved?: BivariantCallback<[summary: unknown]>;
+    onTaskStart?: BivariantCallback<[progress: unknown]>;
+    onTaskComplete?: BivariantCallback<[progress: unknown]>;
+};
+export type ExperimentCallbackFields = {
+    onExperimentStart?: BivariantCallback<[index: number, agent: string]>;
+    onBaselineCollected?: BivariantCallback<[baseline: Record<string, number>]>;
+    onMetricResult?: BivariantCallback<[metric: unknown, result: unknown]>;
+    onCommit?: BivariantCallback<[commitHash: string]>;
+    onReset?: BivariantCallback<[targetHash: string]>;
+    onExperimentComplete?: BivariantCallback<[index: number, entry: unknown]>;
+};
+export type LoopCallbacks = {
+    runRole?: <T>(role: "builder" | "inspector" | "superintendent" | "owner", name: string | undefined, run: () => Promise<T>) => Promise<T>;
+    onBuilderStart?: () => void;
+    onBuilderComplete?: BivariantCallback<[result: unknown]>;
+    onBuilderFailed?: BivariantCallback<[error: Error]>;
+    onInspectorStart?: BivariantCallback<[name: string]>;
+    onInspectorComplete?: BivariantCallback<[result: unknown]>;
+    onInspectorFailed?: BivariantCallback<[name: string, error: Error]>;
+    onSuperintendentStart?: () => void;
+    onSuperintendentComplete?: BivariantCallback<[result: unknown]>;
+    onOwnerStart?: () => void;
+    onOwnerComplete?: BivariantCallback<[result: unknown]>;
+    onRoundComplete?: BivariantCallback<[round: number]>;
+    onLoopComplete?: BivariantCallback<[state: unknown]>;
+    onStateChange?: BivariantCallback<[state: unknown]>;
+    shouldPause?: () => boolean;
+    shouldStop?: () => boolean;
+};
+export declare function mergePipelineCallbacks(user: PipelineCallbackFields | undefined, added: PipelineCallbackFields | undefined): PipelineCallbackFields | undefined;
+export declare function mergeExperimentCallbacks(user: ExperimentCallbackFields | undefined, added: ExperimentCallbackFields | undefined): ExperimentCallbackFields | undefined;
+export declare function mergeLoopCallbacks(user: LoopCallbacks | undefined, added: LoopCallbacks | undefined): LoopCallbacks | undefined;
+export {};

package/dist/poe-code-config/merge.d.ts

@@ -0,0 +1,2 @@
+import type { ConfigDocument } from "./types.js";
+export declare function deepMergeDocuments(base: ConfigDocument, override: ConfigDocument): ConfigDocument;

package/dist/poe-code-config/plan-scope.d.ts

@@ -0,0 +1,8 @@
+export declare const planConfigScope: import("./types.js").ScopeDefinition<{
+    readonly plan_directory: {
+        readonly type: "string";
+        readonly default: "docs/plans";
+        readonly env: "POE_PLAN_DIRECTORY";
+        readonly doc: "Directory where planning documents are stored";
+    };
+}>;

package/dist/poe-code-config/provider-config.d.ts

@@ -0,0 +1,16 @@
+import type { FileSystem } from "../config-mutations/index.js";
+import type { ApiShapeId } from "../providers/index.js";
+export interface ProviderConfigStoreOptions {
+    fs: FileSystem;
+    filePath: string;
+}
+export interface LoadProviderShapeBaseUrlsOptions extends ProviderConfigStoreOptions {
+    providerId: string;
+    readOnly?: boolean;
+}
+export interface SaveProviderShapeBaseUrlsOptions extends ProviderConfigStoreOptions {
+    providerId: string;
+    shapeBaseUrls: Partial<Record<ApiShapeId, string>>;
+}
+export declare function loadProviderShapeBaseUrls(options: LoadProviderShapeBaseUrlsOptions): Promise<Partial<Record<ApiShapeId, string>>>;
+export declare function saveProviderShapeBaseUrls(options: SaveProviderShapeBaseUrlsOptions): Promise<void>;

package/dist/poe-code-config/resolve.d.ts

@@ -0,0 +1,2 @@
+import type { InferConfig, ScopeSchema } from "./types.js";
+export declare function resolveScope<S extends ScopeSchema>(schema: S, fileValues?: Record<string, unknown>, env?: Record<string, string | undefined>): InferConfig<S>;

package/dist/poe-code-config/runtime.d.ts

@@ -0,0 +1,114 @@
+import type { ResolvedConfig } from "./types.js";
+export interface RuntimeMount {
+    source: string;
+    target: string;
+    readonly?: boolean;
+}
+export interface RunnerScope {
+    detach: boolean;
+    upload_max_file_mb: number;
+    download_conflict: "refuse" | "overwrite";
+    sync: "both" | "upload" | "none";
+    workspace?: {
+        exclude?: string[];
+    };
+}
+interface SharedRuntimeFields {
+    build_args: Record<string, string>;
+    mounts: RuntimeMount[];
+    link?: string;
+}
+export interface HostRuntime extends SharedRuntimeFields {
+    type: "host";
+}
+export interface DockerRuntime extends SharedRuntimeFields {
+    type: "docker";
+    image?: string;
+    dockerfile?: string;
+    build_context?: string;
+    engine?: "docker" | "podman";
+    network?: string;
+    extra_args?: string[];
+}
+export type RuntimeConfig = HostRuntime | DockerRuntime;
+export type RuntimeRunner = RuntimeConfig["type"];
+export interface RuntimeResolveResult {
+    runtime: RuntimeConfig;
+    runner: RuntimeRunner;
+    dockerfilePath: string | null;
+    buildContext: string | null;
+}
+export declare const runtimeConfigScope: {
+    scope: string;
+    schema: {
+        type: {
+            type: "string";
+            default: string;
+            doc: string;
+        };
+        build_args: {
+            type: "json";
+            default: Record<string, string>;
+            parse: typeof parseBuildArgs;
+            doc: string;
+        };
+        mounts: {
+            type: "json";
+            default: RuntimeMount[];
+            parse: typeof parseMounts;
+            doc: string;
+        };
+        runner: {
+            type: "json";
+            default: RunnerScope;
+            parse: typeof parseRunner;
+            doc: string;
+        };
+        link: {
+            type: "string";
+            default: string;
+            doc: string;
+        };
+        image: {
+            type: "string";
+            default: string;
+            doc: string;
+        };
+        dockerfile: {
+            type: "string";
+            default: string;
+            doc: string;
+        };
+        build_context: {
+            type: "string";
+            default: string;
+            doc: string;
+        };
+        engine: {
+            type: "string";
+            default: string;
+            doc: string;
+        };
+        network: {
+            type: "string";
+            default: string;
+            doc: string;
+        };
+        extra_args: {
+            type: "json";
+            default: string[] | undefined;
+            parse: typeof parseOptionalStringArray;
+            doc: string;
+        };
+    };
+};
+export declare function parseRunner(raw: unknown): RunnerScope;
+export declare function parseRuntime(raw: unknown): RuntimeConfig;
+export declare function resolveRuntime({ cwd, config }: {
+    cwd: string;
+    config: Pick<ResolvedConfig, "runtime">;
+}): RuntimeResolveResult;
+declare function parseBuildArgs(value: unknown): Record<string, string>;
+declare function parseMounts(value: unknown): RuntimeMount[];
+declare function parseOptionalStringArray(value: unknown, key?: string): string[] | undefined;
+export {};

package/dist/poe-code-config/schema.d.ts

@@ -0,0 +1,14 @@
+import type { BraintrustIntegrationConfig, ScopeDefinition, ScopeSchema } from "./types.js";
+export declare function defineScope<const S extends ScopeSchema>(scope: string, schema: S): ScopeDefinition<S>;
+export declare const integrationsConfigScope: ScopeDefinition<{
+    readonly braintrust: {
+        readonly type: "json";
+        readonly default: {
+            enabled: false;
+        };
+        readonly parse: typeof parseBraintrustIntegrationConfig;
+        readonly doc: "Braintrust integration configuration";
+    };
+}>;
+export { runtimeConfigScope } from "./runtime.js";
+declare function parseBraintrustIntegrationConfig(value: unknown): BraintrustIntegrationConfig;

package/dist/poe-code-config/state/fs.d.ts

@@ -0,0 +1,24 @@
+export interface StateFileSystem {
+    mkdir(path: string, options: {
+        recursive: true;
+    }): Promise<unknown>;
+    readFile(path: string, encoding: BufferEncoding): Promise<string>;
+    writeFile(path: string, data: string, options?: BufferEncoding | {
+        encoding?: BufferEncoding;
+        flag?: string;
+        mode?: number;
+    }): Promise<void>;
+    rename(oldPath: string, newPath: string): Promise<void>;
+    readdir(path: string): Promise<string[]>;
+    stat(path: string): Promise<{
+        isFile(): boolean;
+        mtimeMs: number;
+    }>;
+    lstat?(path: string): Promise<{
+        isSymbolicLink(): boolean;
+    }>;
+    unlink(path: string): Promise<void>;
+}
+export declare const defaultStateFs: StateFileSystem;
+export declare function isNotFoundError(error: unknown): boolean;
+export declare function assertPathHasNoSymbolicLinks(fs: StateFileSystem, targetPath: string, message: string): Promise<void>;

package/dist/poe-code-config/state/index.d.ts

@@ -0,0 +1,12 @@
+import { type JobRegistry } from "./jobs.js";
+import { type TemplateRegistry } from "./templates.js";
+import type { StateFileSystem } from "./fs.js";
+export interface StateManager {
+    templates: TemplateRegistry;
+    jobs: JobRegistry;
+}
+export declare function loadStateManager(homeDir?: string): Promise<StateManager>;
+export declare function createStateManager(homeDir: string, fs?: StateFileSystem): StateManager;
+export { createJobRegistry, type JobEntry, type JobListFilter, type JobRegistry, type JobStatus } from "./jobs.js";
+export { createTemplateRegistry, type TemplateBackend, type TemplateEntry, type TemplateRegistry } from "./templates.js";
+export type { StateFileSystem } from "./fs.js";

package/dist/poe-code-config/state/jobs.d.ts

@@ -0,0 +1,34 @@
+import { type StateFileSystem } from "./fs.js";
+export type JobStatus = "pending" | "running" | "exited" | "killed" | "lost";
+export interface JobEntry {
+    id: string;
+    env_id: string;
+    env_kind: string;
+    tool: string;
+    argv: string[];
+    cwd: string;
+    started_at: string;
+    status: JobStatus;
+    exit_code?: number;
+    exited_at?: string;
+    log_file?: string;
+    reattach_context?: Record<string, unknown>;
+}
+export interface JobListFilter {
+    env_id?: string;
+    env_kind?: string;
+    tool?: string;
+    status?: JobStatus;
+    since?: Date;
+    limit?: number;
+}
+export interface JobRegistry {
+    get(id: string): Promise<JobEntry | null>;
+    put(entry: JobEntry): Promise<void>;
+    update(id: string, patch: Partial<JobEntry>): Promise<JobEntry | null>;
+    /** Newest first, capped by filter.limit when provided. */
+    list(filter?: JobListFilter): Promise<JobEntry[]>;
+    remove(id: string): Promise<void>;
+}
+export declare function createJobRegistry(homeDir: string, fs?: StateFileSystem): JobRegistry;
+export type { StateFileSystem } from "./fs.js";

package/dist/poe-code-config/state/templates.d.ts

@@ -0,0 +1,18 @@
+import { type StateFileSystem } from "./fs.js";
+export type TemplateBackend = "docker";
+export interface TemplateEntry {
+    hash: string;
+    template_id?: string;
+    image?: string;
+    runtime_type: string;
+    dockerfile_path: string;
+    built_at: string;
+}
+export interface TemplateRegistry {
+    get(backend: TemplateBackend, hash: string): Promise<TemplateEntry | null>;
+    put(backend: TemplateBackend, entry: TemplateEntry): Promise<void>;
+    remove(backend: TemplateBackend, hash: string): Promise<void>;
+    list(backend?: TemplateBackend): Promise<TemplateEntry[]>;
+}
+export declare function createTemplateRegistry(homeDir: string, fs?: StateFileSystem): TemplateRegistry;
+export type { StateFileSystem } from "./fs.js";

package/dist/poe-code-config/store.d.ts

@@ -0,0 +1,12 @@
+import { type FileSystem } from "../config-mutations/index.js";
+import type { ConfigDocument } from "./types.js";
+export declare function readDocument(fs: FileSystem, filePath: string): Promise<ConfigDocument>;
+export declare function readDocumentReadonly(fs: FileSystem, filePath: string): Promise<ConfigDocument>;
+export declare function writeScope(fs: FileSystem, filePath: string, scope: string, values: Record<string, unknown>): Promise<void>;
+export declare function readMergedDocument(fs: FileSystem, globalPath: string, projectPath?: string): Promise<ConfigDocument>;
+export declare function readMergedDocumentReadonly(fs: FileSystem, globalPath: string, projectPath?: string): Promise<ConfigDocument>;
+export declare function writeDocument(fs: FileSystem, filePath: string, document: ConfigDocument): Promise<void>;
+export declare function assertConfigPathSafe(fs: FileSystem, filePath: string): Promise<void>;
+export declare function resolveConfigPath(homeDir: string): string;
+export declare function resolveServicesConfigPath(homeDir: string): string;
+export declare function resolveProjectConfigPath(cwd: string): string;

package/dist/poe-code-config/types.d.ts

@@ -0,0 +1,88 @@
+import type { FileSystem } from "../config-mutations/index.js";
+import type { RunnerScope, RuntimeConfig } from "./runtime.js";
+export type PrimitiveConfigFieldType = "string" | "number" | "boolean";
+export type ConfigFieldType = PrimitiveConfigFieldType | "json";
+export interface TypeMap {
+    string: string;
+    number: number;
+    boolean: boolean;
+}
+export interface PrimitiveSchemaField<T extends PrimitiveConfigFieldType = PrimitiveConfigFieldType> {
+    type: T;
+    default: TypeMap[T];
+    doc: string;
+    env?: string;
+}
+export interface JsonSchemaField<T = unknown> {
+    type: "json";
+    default: T;
+    parse: (value: unknown) => T;
+    doc: string;
+    env?: string;
+}
+export type SchemaField = PrimitiveSchemaField | JsonSchemaField;
+export type InferSchemaField<T extends SchemaField> = T extends PrimitiveSchemaField<infer U> ? TypeMap[U] : T extends JsonSchemaField<infer U> ? U : never;
+export type ScopeSchema = Record<string, SchemaField>;
+export type InferConfig<S extends ScopeSchema> = {
+    [K in keyof S]: InferSchemaField<S[K]>;
+};
+export interface ScopeDefinition<S extends ScopeSchema> {
+    scope: string;
+    schema: S;
+}
+export interface MemoryConfidenceConfig extends Record<string, unknown> {
+    rejectUntagged?: boolean;
+    minInferredConfidence?: number;
+}
+export interface MemoryCacheConfig extends Record<string, unknown> {
+    enabled?: boolean;
+    maxAgeMs?: number;
+}
+export interface MemoryMcpConfig extends Record<string, unknown> {
+    allowWrites?: boolean;
+}
+export interface MemoryQueryConfig extends Record<string, unknown> {
+    defaultBudgetTokens?: number;
+}
+export interface MemoryConfig extends Record<string, unknown> {
+    root?: string;
+    ingestAgent?: string;
+    ingestTimeoutMs?: number;
+    maxPageBytes?: number;
+    confidence?: MemoryConfidenceConfig;
+    cache?: MemoryCacheConfig;
+    mcp?: MemoryMcpConfig;
+    query?: MemoryQueryConfig;
+}
+export interface BraintrustIntegrationConfig extends Record<string, unknown> {
+    enabled: boolean;
+    apiKey?: string;
+    apiUrl?: string;
+    project?: string;
+}
+export interface IntegrationsConfig extends Record<string, unknown> {
+    braintrust?: BraintrustIntegrationConfig;
+}
+export interface ScopedConfig<S extends ScopeSchema> {
+    get<K extends keyof S & string>(key: K): Promise<InferConfig<S>[K]>;
+    getAll(): Promise<InferConfig<S>>;
+    set<K extends keyof S & string>(key: K, value: InferConfig<S>[K]): Promise<void>;
+}
+export interface ConfigStore {
+    scope<S extends ScopeSchema>(definition: ScopeDefinition<S>): ScopedConfig<S>;
+}
+export interface ConfigStoreOptions {
+    fs: FileSystem;
+    filePath: string;
+    projectFilePath?: string;
+    env?: Record<string, string | undefined>;
+}
+export type ConfigDocument = Record<string, Record<string, unknown>> & {
+    integrations?: IntegrationsConfig;
+    memory?: MemoryConfig;
+    runtime?: Record<string, unknown>;
+};
+export interface ResolvedConfig {
+    runtime: RuntimeConfig;
+    runner: RunnerScope;
+}