lopata 0.20.0 → 0.20.1

package/dist/types/bindings/ai-search.d.ts

@@ -0,0 +1,44 @@
+import type { Database } from 'bun:sqlite';
+interface CreateInstanceOptions {
+    id: string;
+    type?: string;
+    source?: unknown;
+}
+interface SearchOptions {
+    messages: {
+        role: string;
+        content: string;
+    }[];
+    ai_search_options?: {
+        instance_ids?: string[];
+        [key: string]: unknown;
+    };
+    stream?: boolean;
+    [key: string]: unknown;
+}
+export declare class AiSearchInstance {
+    private readonly binding;
+    readonly id: string;
+    readonly metadata: Record<string, unknown>;
+    constructor(binding: AiSearchNamespaceBinding, id: string, metadata?: Record<string, unknown>);
+    search(options: SearchOptions): Promise<unknown>;
+    chatCompletions(options: SearchOptions): Promise<unknown>;
+}
+export declare class AiSearchNamespaceBinding {
+    private readonly db;
+    private readonly namespace;
+    private readonly accountId?;
+    private readonly apiToken?;
+    constructor(db: Database, namespace: string, accountId?: string, apiToken?: string);
+    private ensureCredentials;
+    create(opts: CreateInstanceOptions): Promise<AiSearchInstance>;
+    get(id: string): Promise<AiSearchInstance>;
+    list(opts?: Record<string, string>): Promise<unknown>;
+    delete(id: string): Promise<boolean>;
+    search(options: SearchOptions): Promise<unknown>;
+    chatCompletions(options: SearchOptions): Promise<unknown>;
+    /** @internal — called by AiSearchInstance */
+    _proxyInstance(method: 'search' | 'chatCompletions', instanceId: string, options: SearchOptions): Promise<unknown>;
+    private proxy;
+}
+export {};

package/dist/types/bindings/artifacts-git-http.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Git HTTP protocol handler for the Artifacts binding.
+ *
+ * Proxies `/__artifacts/git/<repo-id>.git/<path>` requests to the `git http-backend`
+ * CGI binary. Authentication is via HTTP Basic (username ignored, password = token
+ * from `artifacts_tokens`). Read operations (`git-upload-pack`) accept any non-revoked
+ * token; write operations (`git-receive-pack`) require a `write`-scoped token.
+ *
+ * Repos marked read-only (`read_only = 1`) reject write requests regardless of scope.
+ */
+import type { Database } from 'bun:sqlite';
+export interface ArtifactsGitHandlerOptions {
+    db: Database;
+    artifactsDir: string;
+    gitBinary?: string;
+    /** When true (tests), skip token validation. */
+    skipAuth?: boolean;
+}
+export declare function handleArtifactsGitRequest(request: Request, opts: ArtifactsGitHandlerOptions): Promise<Response | null>;

package/dist/types/bindings/artifacts.d.ts

@@ -0,0 +1,108 @@
+import type { Database } from 'bun:sqlite';
+export type ArtifactsTokenScope = 'read' | 'write';
+export interface CreateRepoOpts {
+    readOnly?: boolean;
+    description?: string;
+    setDefaultBranch?: string;
+}
+export interface CreateRepoResult {
+    id: string;
+    name: string;
+    description: string | null;
+    defaultBranch: string;
+    remote: string;
+    token: string;
+}
+export interface TokenResult {
+    id: string;
+    plaintext: string;
+    scope: ArtifactsTokenScope;
+    expiresAt: string | null;
+}
+export interface ListReposOpts {
+    limit?: number;
+    cursor?: string;
+}
+export interface RepoListResult {
+    repos: {
+        id: string;
+        name: string;
+        remote: string;
+        defaultBranch: string;
+        description: string | null;
+    }[];
+    cursor: string | null;
+}
+export interface TokenListResult {
+    total: number;
+    tokens: {
+        id: string;
+        scope: ArtifactsTokenScope;
+        expiresAt: string | null;
+        createdAt: string;
+    }[];
+}
+export interface ImportParams {
+    source: {
+        url: string;
+        branch?: string;
+        depth?: number;
+    };
+    target: {
+        name: string;
+        opts?: CreateRepoOpts;
+    };
+}
+export interface ForkOpts {
+    description?: string;
+    readOnly?: boolean;
+    defaultBranchOnly?: boolean;
+}
+interface RepoRow {
+    id: string;
+    namespace: string;
+    name: string;
+    description: string | null;
+    default_branch: string;
+    read_only: number;
+    forked_from: string | null;
+    created_at: number;
+}
+export declare class ArtifactsBinding {
+    private readonly db;
+    private readonly namespace;
+    private readonly artifactsDir;
+    private readonly remoteBase;
+    private readonly gitBinary;
+    constructor(db: Database, namespace: string, artifactsDir: string, remoteBase: string, gitBinary?: string);
+    private repoDir;
+    private buildRemote;
+    create(name: string, opts?: CreateRepoOpts): Promise<CreateRepoResult>;
+    get(name: string): Promise<ArtifactsRepo>;
+    list(opts?: ListReposOpts): Promise<RepoListResult>;
+    import(params: ImportParams): Promise<CreateRepoResult>;
+    delete(name: string): Promise<boolean>;
+    /** @internal — also called by `ArtifactsRepo.fork()` */
+    _forkRepo(source: RepoRow, newName: string, opts?: ForkOpts): Promise<CreateRepoResult>;
+    /** @internal — called by `ArtifactsRepo.createToken()`, `ArtifactsBinding.create()`. */
+    issueToken(repoId: string, scope: ArtifactsTokenScope, ttlSeconds?: number): TokenResult;
+    /** @internal */
+    listTokens(repoId: string): TokenListResult;
+    /** @internal */
+    revokeTokenById(repoId: string, tokenOrId: string): boolean;
+}
+export declare class ArtifactsRepo {
+    private readonly binding;
+    private readonly row;
+    readonly remote: string;
+    constructor(binding: ArtifactsBinding, row: RepoRow, remote: string);
+    get id(): string;
+    get name(): string;
+    get defaultBranch(): string;
+    get description(): string | null;
+    createToken(scope?: ArtifactsTokenScope, ttl?: number): Promise<TokenResult>;
+    listTokens(): Promise<TokenListResult>;
+    revokeToken(tokenOrId: string): Promise<boolean>;
+    fork(name: string, opts?: ForkOpts): Promise<CreateRepoResult>;
+}
+export {};

package/dist/types/bindings/flagship.d.ts

@@ -0,0 +1,37 @@
+import type { Database } from 'bun:sqlite';
+export type FlagType = 'boolean' | 'string' | 'number' | 'object';
+export interface FlagDetails<T> {
+    value: T;
+    variant?: string;
+    reason: 'STATIC' | 'DEFAULT' | 'ERROR' | 'TARGETING_MATCH';
+    errorCode?: string;
+}
+type EvaluationContext = Record<string, unknown> | undefined;
+/**
+ * Local implementation of the Cloudflare Flagship feature-flag binding.
+ * Flag values are stored in SQLite (`flagship_flags` table). When a flag is
+ * not found, the caller's `defaultValue` is returned with reason `DEFAULT`.
+ * Local dev does not implement targeting rules — the `context` argument is
+ * accepted for API compatibility but ignored during evaluation.
+ */
+export declare class FlagshipBinding {
+    private db;
+    private appId;
+    constructor(db: Database, appId: string);
+    getBooleanValue(key: string, defaultValue: boolean, context?: EvaluationContext): Promise<boolean>;
+    getStringValue(key: string, defaultValue: string, context?: EvaluationContext): Promise<string>;
+    getNumberValue(key: string, defaultValue: number, context?: EvaluationContext): Promise<number>;
+    getObjectValue<T>(key: string, defaultValue: T, context?: EvaluationContext): Promise<T>;
+    getBooleanValueDetails(key: string, defaultValue: boolean, _context?: EvaluationContext): Promise<FlagDetails<boolean>>;
+    getStringValueDetails(key: string, defaultValue: string, _context?: EvaluationContext): Promise<FlagDetails<string>>;
+    getNumberValueDetails(key: string, defaultValue: number, _context?: EvaluationContext): Promise<FlagDetails<number>>;
+    getObjectValueDetails<T>(key: string, defaultValue: T, _context?: EvaluationContext): Promise<FlagDetails<T>>;
+    private evaluate;
+}
+/**
+ * Programmatic helper to seed / override a flag value in the local store.
+ * Used by tests and (later) the dashboard.
+ */
+export declare function setFlagValue(db: Database, appId: string, key: string, type: FlagType, value: unknown, variant?: string): void;
+export declare function deleteFlag(db: Database, appId: string, key: string): void;
+export {};

package/dist/types/bindings/vpc-network.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Local implementation of the Cloudflare VPC Networks binding (`vpc_networks`).
+ *
+ * On Cloudflare, this binding exposes a Fetcher-like `fetch()` method that
+ * routes the request through the bound tunnel or Cloudflare Mesh. The URL
+ * passed to `fetch()` determines the destination host/port.
+ *
+ * In local dev there is no tunnel overlay network, so we pass the request
+ * straight to the host system's stack — the caller is expected to arrange
+ * for the destination to be reachable locally (e.g. a dev service on a
+ * known port, or a VPN/WireGuard tunnel on the host).
+ */
+export interface VpcNetworkConfig {
+    networkId: string;
+    bindingName: string;
+}
+export declare class VpcNetworkBinding {
+    private config;
+    constructor(config: VpcNetworkConfig);
+    get networkId(): string;
+    fetch(input: string | URL | Request, init?: RequestInit): Promise<Response>;
+}

package/dist/types/bindings/worker-loader-entry.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Worker-thread entry for the `worker_loaders` binding.
+ *
+ * The main thread spawns this file as a Worker, sends an init message with
+ * the path to the dynamically-written main module + a serializable `env`
+ * object, then dispatches RPC commands. Each command invokes either the
+ * default export's `fetch()` (HTTP), `scheduled()` (cron), or a named method
+ * on a named entrypoint class.
+ *
+ * This is "fuzzy" isolation — the worker thread has its own heap and module
+ * graph but shares the same process, so `fetch()` / `connect()` / filesystem
+ * access behave identically to the parent.
+ */
+export interface LoaderInitMessage {
+    type: 'init';
+    mainModulePath: string;
+    env: unknown;
+    globalOutbound: 'allow' | 'block';
+}
+export type LoaderCommand = {
+    type: 'fetch';
+    entrypoint?: string;
+    url: string;
+    method: string;
+    headers: [string, string][];
+    body: ArrayBuffer | null;
+} | {
+    type: 'scheduled';
+    entrypoint?: string;
+    cron: string;
+    scheduledTime: number;
+} | {
+    type: 'rpc-call';
+    entrypoint?: string;
+    method: string;
+    args: unknown[];
+};
+export type LoaderResult = {
+    type: 'fetch';
+    status: number;
+    statusText: string;
+    headers: [string, string][];
+    body: ArrayBuffer | null;
+} | {
+    type: 'scheduled';
+} | {
+    type: 'rpc-call';
+    value: unknown;
+} | {
+    type: 'error';
+    message: string;
+    stack?: string;
+    name?: string;
+};
+export type MainToWorker = {
+    type: 'init';
+    data: LoaderInitMessage;
+} | {
+    type: 'command';
+    id: number;
+    command: LoaderCommand;
+};
+export type WorkerToMain = {
+    type: 'need-init';
+} | {
+    type: 'ready';
+} | {
+    type: 'result';
+    id: number;
+    result: LoaderResult;
+};

package/dist/types/bindings/worker-loader.d.ts

@@ -0,0 +1,81 @@
+/**
+ * Local implementation of the Cloudflare `worker_loaders` binding.
+ *
+ * Exposes `env.LOADER.load(code)` / `env.LOADER.get(id, callback)`. Each load
+ * spawns a Bun Worker thread (see `worker-loader-entry.ts`) that runs the
+ * supplied code with its own module graph. Isolation is "fuzzy" — worker
+ * threads share the process with the parent but have separate heaps.
+ *
+ * Modules are written to `.lopata/worker-loader/<stub-id>/` before the Worker
+ * imports the entry point. This keeps the implementation simple at the cost
+ * of not supporting languages Bun can't execute directly (CF's `py`, Rust,
+ * etc. are rejected in v1).
+ */
+export type WorkerCodeModule = string | {
+    js: string;
+} | {
+    cjs: string;
+} | {
+    text: string;
+} | {
+    data: ArrayBuffer;
+} | {
+    json: unknown;
+};
+export interface WorkerCode {
+    compatibilityDate: string;
+    compatibilityFlags?: string[];
+    mainModule: string;
+    modules: Record<string, WorkerCodeModule>;
+    env?: Record<string, unknown>;
+    globalOutbound?: unknown | null;
+    allowExperimental?: boolean;
+    tails?: unknown[];
+    limits?: {
+        cpuMs?: number;
+        subRequests?: number;
+    };
+}
+type CodeSource = WorkerCode | (() => WorkerCode | Promise<WorkerCode>);
+export declare class WorkerStub {
+    private readonly id;
+    private readonly codeSource;
+    private _resolvedCode;
+    private readonly workDir;
+    private _worker;
+    private _ready;
+    private _pending;
+    private _nextCmdId;
+    private _disposed;
+    private _disposeTimer;
+    constructor(id: string, code: CodeSource, baseDir: string);
+    private _resolveCode;
+    private _ensureReady;
+    private _boot;
+    private _send;
+    getEntrypoint(name?: string): EntrypointProxy;
+    /** @internal */
+    _fetch(entrypoint: string | undefined, request: Request): Promise<Response>;
+    /** @internal */
+    _scheduled(entrypoint: string | undefined, cron: string, scheduledTime: number): Promise<void>;
+    /** @internal */
+    _rpcCall(entrypoint: string | undefined, method: string, args: unknown[]): Promise<unknown>;
+    dispose(): void;
+}
+export interface EntrypointProxy {
+    fetch(request: Request | string | URL, init?: RequestInit): Promise<Response>;
+    scheduled(event: {
+        cron: string;
+        scheduledTime?: number;
+    }): Promise<void>;
+    [method: string]: unknown;
+}
+export declare class WorkerLoaderBinding {
+    private readonly baseDir;
+    private readonly cache;
+    constructor(baseDir: string);
+    load(code: WorkerCode): WorkerStub;
+    get(id: string, getCodeCallback: () => Promise<WorkerCode> | WorkerCode): WorkerStub;
+    disposeAll(): void;
+}
+export {};

package/dist/types/config.d.ts

@@ -50,15 +50,34 @@ export interface WranglerConfig {
         name: string;
         destination_address?: string;
         allowed_destination_addresses?: string[];
+        remote?: boolean;
     }[];
     ai?: {
         binding: string;
     };
+    ai_search_namespaces?: {
+        binding: string;
+        namespace: string;
+        remote?: boolean;
+    }[];
+    artifacts?: {
+        binding: string;
+        namespace: string;
+    }[];
+    worker_loaders?: {
+        binding: string;
+    }[];
     hyperdrive?: {
         binding: string;
         id: string;
         localConnectionString?: string;
     }[];
+    vpc_networks?: {
+        binding: string;
+        network_id?: string;
+        tunnel_id?: string;
+        remote?: boolean;
+    }[];
     services?: {
         binding: string;
         service: string;
@@ -104,6 +123,10 @@ export interface WranglerConfig {
     version_metadata?: {
         binding: string;
     };
+    flagship?: {
+        binding: string;
+        app_id: string;
+    };
     migrations?: {
         tag: string;
         new_classes?: string[];

package/dist/types/env.d.ts

@@ -52,7 +52,9 @@ export declare function buildEnv(config: WranglerConfig, devVarsDir?: string, ex
     wsEndpoint?: string;
     executablePath?: string;
     headless?: boolean;
-}, existingNamespaces?: Map<string, DurableObjectNamespaceImpl>): {
+}, existingNamespaces?: Map<string, DurableObjectNamespaceImpl>, baseUrls?: {
+    artifacts?: string;
+}): {
     env: Record<string, unknown>;
     registry: ClassRegistry;
 };

package/dist/types/generation-manager.d.ts

@@ -35,6 +35,9 @@ export declare class GenerationManager {
         executablePath?: string;
         headless?: boolean;
     } | undefined;
+    readonly baseUrls: {
+        artifacts?: string;
+    } | undefined;
     /** @internal Path to the wrangler config file (DO worker threads re-load it). */
     _configPath: string;
     constructor(config: WranglerConfig, baseDir: string, options?: {
@@ -49,6 +52,9 @@ export declare class GenerationManager {
             executablePath?: string;
             headless?: boolean;
         };
+        baseUrls?: {
+            artifacts?: string;
+        };
     });
     /** The currently active generation (receives new requests) */
     get active(): Generation | null;