apps 0.0.1-beta.4 → 0.0.1-beta.41

package/js/chunk-SWPD52J7.js

@@ -1,35 +0,0 @@
-import {
-  Schema_exports
-} from "./chunk-FW5HBOIK.js";
-
-// src/contracts/api-response-error.ts
-var ApiErrorRecovery = Schema_exports.Struct({
-  action: Schema_exports.NonEmptyString.check(Schema_exports.isMaxLength(1024)),
-  instructions: Schema_exports.NonEmptyString.check(Schema_exports.isMaxLength(4096))
-});
-var ApiErrorResponse = Schema_exports.Struct({
-  code: Schema_exports.NonEmptyString.check(Schema_exports.isMaxLength(128)),
-  status: Schema_exports.Int.check(Schema_exports.isBetween({ minimum: 400, maximum: 599 })),
-  message: Schema_exports.NonEmptyString.check(Schema_exports.isMaxLength(4096)),
-  recovery: Schema_exports.optionalKey(ApiErrorRecovery)
-});
-var OpenapiResponseError = class extends Schema_exports.TaggedError()(
-  "OpenapiResponseError",
-  ApiErrorResponse.fields
-) {
-};
-var OpenapiErrorLimits = Schema_exports.Struct({
-  maxBodyBytes: Schema_exports.Int.check(Schema_exports.isGreaterThan(0)),
-  readTimeoutMs: Schema_exports.Int.check(Schema_exports.isGreaterThan(0))
-});
-var defaultOpenapiErrorLimits = OpenapiErrorLimits.make({
-  maxBodyBytes: 65536,
-  readTimeoutMs: 2e3
-});
-
-export {
-  ApiErrorRecovery,
-  ApiErrorResponse,
-  OpenapiResponseError,
-  defaultOpenapiErrorLimits
-};

package/js/chunk-W7D7WVSY.js

@@ -1,18 +0,0 @@
-import {
-  AccountId
-} from "./chunk-SATWJKN6.js";
-import {
-  Schema_exports
-} from "./chunk-FW5HBOIK.js";
-
-// src/contracts/provider-error.ts
-var ProviderError = class extends Schema_exports.TaggedError()("ProviderError", {
-  reason: Schema_exports.Literals(["unauthorized", "forbidden", "rate_limited", "unavailable", "rejected"]),
-  status: Schema_exports.optional(Schema_exports.Int.check(Schema_exports.isBetween({ minimum: 100, maximum: 599 }))),
-  accountId: Schema_exports.optional(AccountId)
-}) {
-};
-
-export {
-  ProviderError
-};

package/js/chunk-Z5NMEGJN.js

@@ -1,29 +0,0 @@
-import {
-  operationDeclaration
-} from "./chunk-PYUYJRSK.js";
-
-// src/implementation/protocol-operations.ts
-var protocolOperations = (operations, kinds = {}) => {
-  const queries = {};
-  const mutations = {};
-  for (const [name, operation] of Object.entries(operations)) {
-    const kind = Object.hasOwn(kinds, name) ? kinds[name] : operation.readOnly === true ? "query" : "mutation";
-    const native = {
-      description: operation.description,
-      ...operation.title === void 0 ? {} : { title: operation.title },
-      ...operation.annotations === void 0 ? {} : { annotations: operation.annotations },
-      ...operation._meta === void 0 ? {} : { _meta: operation._meta },
-      input: operation.input,
-      run: operation.run
-    };
-    const output = Object.getOwnPropertyDescriptor(operation, "outputSchema");
-    const withOutput = (target) => output === void 0 || output.get === void 0 && output.value === void 0 ? target : Object.defineProperty(target, "outputSchema", { ...output, enumerable: true });
-    if (kind === "query") queries[name] = operationDeclaration(withOutput({ ...native, kind }));
-    else mutations[name] = operationDeclaration(withOutput({ ...native, kind: "mutation" }));
-  }
-  return { queries, mutations };
-};
-
-export {
-  protocolOperations
-};

package/js/chunk-ZJWDMTE3.js

@@ -1,63 +0,0 @@
-import {
-  ProviderError
-} from "./chunk-W7D7WVSY.js";
-import {
-  AccountId
-} from "./chunk-SATWJKN6.js";
-import {
-  Option_exports,
-  Schema_exports
-} from "./chunk-FW5HBOIK.js";
-
-// src/implementation/provider-error.ts
-function parseProviderError(error) {
-  return Schema_exports.decodeUnknownOption(ProviderError)(error).pipe(
-    Option_exports.map(({ reason, status, accountId }) => new ProviderError({ reason, status, accountId }))
-  );
-}
-function httpProviderError(status, headers = {}) {
-  if (status >= 500 && status <= 599) return new ProviderError({ reason: "unavailable", status });
-  if (status === 401) return new ProviderError({ reason: "unauthorized", status });
-  if (status === 429) return new ProviderError({ reason: "rate_limited", status });
-  if (status !== 403) return void 0;
-  const retry = headers["retry-after"];
-  if (headers["x-ratelimit-remaining"] === "0" || retry !== void 0 && (/^\d+$/.test(retry) || Number.isFinite(Date.parse(retry))))
-    return new ProviderError({ reason: "rate_limited", status });
-  if (/\bBearer\b.*\berror="insufficient_scope"/i.test(headers["www-authenticate"] ?? ""))
-    return new ProviderError({ reason: "forbidden", status });
-  return new ProviderError({ reason: "rejected", status });
-}
-function accountProviderError(error, accountId) {
-  const parsed = parseProviderError(error);
-  const account = Schema_exports.decodeUnknownOption(AccountId)(accountId);
-  if (Option_exports.isNone(parsed) || Option_exports.isNone(account)) return error;
-  return new ProviderError({
-    reason: parsed.value.reason,
-    status: parsed.value.status,
-    accountId: account.value
-  });
-}
-function graphqlProviderError(errors, status) {
-  const codes = errors.flatMap((error) => {
-    const parsed = Schema_exports.decodeUnknownOption(
-      Schema_exports.Struct({
-        type: Schema_exports.optional(Schema_exports.String),
-        extensions: Schema_exports.optional(Schema_exports.Struct({ code: Schema_exports.optional(Schema_exports.String) }))
-      })
-    )(error);
-    return Option_exports.isSome(parsed) ? [parsed.value.type, parsed.value.extensions?.code] : [];
-  });
-  if (codes.includes("RATE_LIMITED") || codes.includes("TOO_MANY_REQUESTS"))
-    return new ProviderError({ reason: "rate_limited", status });
-  if (codes.includes("UNAUTHENTICATED"))
-    return new ProviderError({ reason: "unauthorized", status });
-  if (codes.includes("FORBIDDEN")) return new ProviderError({ reason: "forbidden", status });
-  return void 0;
-}
-
-export {
-  parseProviderError,
-  httpProviderError,
-  accountProviderError,
-  graphqlProviderError
-};

package/types/app-data/src/implementation/cursor.d.ts

@@ -1,10 +0,0 @@
-/** Authenticated, opaque continuation tokens tied to one installation, schema and query plan. */
-import { Effect } from "effect";
-import { AppDatabaseError } from "../contracts/database.js";
-/** Stable SHA-256 fingerprints contain no raw query arguments in logs or metadata keys. */
-export declare const fingerprint: (crypto: Crypto, value: string) => Effect.Effect<string, AppDatabaseError, never>;
-/** Capture a per-database key. Nonces are fresh, and malformed/tampered/cross-query cursors fail closed. */
-export declare const cursorCodec: (crypto: Crypto, bytes: Uint8Array) => Effect.Effect<{
-    encode: (query: string, position: Uint8Array) => Effect.Effect<string, AppDatabaseError, never>;
-    decode: (query: string, token: string) => Effect.Effect<Uint8Array<ArrayBufferLike>, AppDatabaseError, never>;
-}, AppDatabaseError, never>;

package/types/app-data/src/implementation/index-key.d.ts

@@ -1,7 +0,0 @@
-/** Order-preserving scalar tuples. SQLite BLOB ordering supplies bounded prefix/range scans. */
-import { Effect } from "effect";
-import { AppDatabaseError, type Scalar } from "../contracts/database.js";
-/** Compare UTF-8 strings, booleans and finite doubles consistently, with absence before present values. */
-export declare const encodeIndexKey: (values: readonly (Scalar | null)[], maximum?: number) => Effect.Effect<Uint8Array<ArrayBuffer>, AppDatabaseError, never>;
-/** Exclusive upper bound for all tuples beginning with this prefix. */
-export declare const prefixEnd: (prefix: Uint8Array) => Uint8Array | undefined;

package/types/app-data/src/implementation/promise.d.ts

@@ -1,68 +0,0 @@
-import { Row, type DatabaseSession } from "../contracts/database.js";
-/** Index predicates are accumulated immutably, then checked against the declaration by the engine. */
-export interface IndexRange<Fields> {
-    /** Constrain an index prefix field to one value. Null matches a cleared optional field. */
-    readonly eq: <Key extends keyof Fields & string>(field: Key, value: Fields[Key] | null) => IndexRange<Fields>;
-    /** Require a value greater than the bound on the next index field. */
-    readonly gt: <Key extends keyof Fields & string>(field: Key, value: Fields[Key]) => IndexRange<Fields>;
-    /** Require a value greater than or equal to the bound on the next index field. */
-    readonly gte: <Key extends keyof Fields & string>(field: Key, value: Fields[Key]) => IndexRange<Fields>;
-    /** Require a value less than the bound on the next index field. */
-    readonly lt: <Key extends keyof Fields & string>(field: Key, value: Fields[Key]) => IndexRange<Fields>;
-    /** Require a value less than or equal to the bound on the next index field. */
-    readonly lte: <Key extends keyof Fields & string>(field: Key, value: Fields[Key]) => IndexRange<Fields>;
-}
-/** Bounded indexed reads; collect/count reject work beyond the invocation budget. */
-export interface Query<Row> {
-    /** Choose ascending or descending index order without changing this query. */
-    readonly order: (direction: "asc" | "desc") => Query<Row>;
-    /** Read all matching rows within the invocation budget; exceeding it fails. */
-    readonly collect: () => Promise<readonly Row[]>;
-    /** Count matching rows within the scan budget; exceeding it fails. */
-    readonly count: () => Promise<number>;
-    /** Read the first matching row, or null when no row matches. */
-    readonly first: () => Promise<Row | null>;
-    /** Read at most count matching rows within the invocation budget. */
-    readonly take: (count: number) => Promise<readonly Row[]>;
-    /** Read one cursor page. Return its rows, continuation cursor and completion flag. */
-    readonly paginate: (options: {
-        readonly numItems: number;
-        readonly cursor: string | null;
-    }) => Promise<{
-        readonly page: readonly Row[];
-        readonly continueCursor: string | null;
-        readonly isDone: boolean;
-    }>;
-}
-/** Typed table operations exposed to authored queries. */
-export interface ReadTable<Row, Index extends string = string> {
-    /** Read a complete row by ID, or null when it does not exist. */
-    readonly get: (id: string) => Promise<Row | null>;
-    /** Select a declared index or by_creation, with optional prefix and range constraints. */
-    readonly withIndex: (index: Index | "by_creation", range?: (query: IndexRange<Row>) => IndexRange<Row>) => Query<Row>;
-}
-/** Writes are valid only inside their owning mutation. */
-export interface WriteTable<Row, Insert, Index extends string = string> extends ReadTable<Row, Index> {
-    /** Insert authored fields and return the complete row with generated id, createdAt and updatedAt. */
-    readonly insert: (value: Insert) => Promise<Row>;
-    /** Patch authored fields and return the complete row, or null if the ID does not exist. */
-    readonly update: (id: string, patch: Partial<Insert>) => Promise<Row | null>;
-    /** Delete the row and return whether it existed. */
-    readonly delete: (id: string) => Promise<boolean>;
-}
-/** Build an untyped transport facade; the author schema layer installs exact field and row decoders. */
-export declare const promiseTable: (session: DatabaseSession, table: string, signal: AbortSignal) => {
-    get: (id: string) => Promise<{
-        readonly [x: string]: string | number | boolean;
-    } | null>;
-    insert: (value: unknown) => Promise<{
-        readonly [x: string]: string | number | boolean;
-    }>;
-    update: (id: string, patch: unknown) => Promise<{
-        readonly [x: string]: string | number | boolean;
-    } | null>;
-    delete: (id: string) => Promise<boolean>;
-    withIndex: (index: string, range?: (query: IndexRange<Row>) => IndexRange<Row>) => Query<{
-        readonly [x: string]: string | number | boolean;
-    }>;
-};

package/types/app-data/src/implementation/range.d.ts

@@ -1,8 +0,0 @@
-/** Index-prefix equality followed by at most one field's lower and upper bounds. */
-import { Effect } from "effect";
-import { AppDatabaseError, type QueryPlan, type Table } from "../contracts/database.js";
-/** Produce half-open BLOB bounds; absent optional values do not satisfy ordinary range predicates. */
-export declare const queryBounds: (table: Table, plan: QueryPlan, maximum: number) => Effect.Effect<{
-    lower: Uint8Array<ArrayBufferLike>;
-    upper: Uint8Array<ArrayBufferLike> | undefined;
-}, AppDatabaseError, never>;

package/types/app-data/src/implementation/schema.d.ts

@@ -1,33 +0,0 @@
-/** Validate declarations and write values before touching SQLite. */
-import { Effect } from "effect";
-import { AppDatabaseError, DatabaseSchema, RowMetadata, type Field, type Row, type Scalar, type Table } from "../contracts/database.js";
-/** Built-in creation ordering and stable tie-breakers apply to every index. */
-export declare const indexesFor: (table: Table) => {
-    name: string;
-    fields: string[];
-}[];
-/** Metadata fields have stable string semantics and cannot be overwritten. */
-export declare const fieldFor: (table: Table, name: string) => Field | undefined;
-/** Finite numbers and well-formed strings keep JSON and index ordering consistent. */
-export declare const validScalar: (field: Field, value: unknown) => value is Scalar;
-/** Parse the whole schema, including references and composite-index definitions. */
-export declare const parseDatabaseSchema: (input: unknown) => Effect.Effect<{
-    readonly [x: string]: {
-        readonly fields: {
-            readonly [x: string]: {
-                readonly kind: "string" | "number" | "boolean" | "id" | "userId";
-                readonly optional?: boolean | undefined;
-                readonly default?: string | number | boolean | undefined;
-                readonly references?: string | undefined;
-            };
-        };
-        readonly indexes: readonly {
-            readonly name: string;
-            readonly fields: readonly [string, ...string[]];
-        }[];
-    };
-}, AppDatabaseError, never>;
-/** Canonical ordering for schema fingerprints and query-bound cursors. */
-export declare const canonicalSchema: (schema: DatabaseSchema) => string;
-/** Inserts apply declared defaults; updates reject unknown/metadata fields and clear optional values with null. */
-export declare const writeValue: (table: Table, values: Readonly<Record<string, Scalar | null>>, previous: Row | undefined, meta: typeof RowMetadata.Type) => Effect.Effect<Record<string, string | number | boolean>, AppDatabaseError, never>;

package/types/app-data/src/implementation/sqlite.d.ts

@@ -1,11 +0,0 @@
-/** Shared SQLite engine. Drivers, persistent paths and app ownership belong to the host. */
-import { Effect } from "effect";
-import type { SqlClient } from "effect/unstable/sql/SqlClient";
-import { AppDatabaseError, DatabaseLimits, type AppDatabase } from "../contracts/database.js";
-/** Open a database whose storage is owned by exactly one configured app. Schema changes fail closed. */
-export declare const makeSqliteDatabase: (options: {
-    readonly sql: SqlClient;
-    readonly schema: unknown;
-    readonly crypto: Crypto;
-    readonly limits?: DatabaseLimits;
-}) => Effect.Effect<AppDatabase, AppDatabaseError>;

package/types/app-data/src/index.d.ts

@@ -1,4 +0,0 @@
-/** Portable, app-owned database engine and contracts. */
-export * from "./contracts/database.js";
-export { makeSqliteDatabase } from "./implementation/sqlite.js";
-export { promiseTable, type IndexRange, type Query, type ReadTable, type WriteTable, } from "./implementation/promise.js";

package/types/apps/src/contracts/dynamic-tools.d.ts

@@ -1,13 +0,0 @@
-/** Lazy operation discovery and resolution. Executables remain invocation-owned. */
-import type { Effect } from "effect";
-import type { HostedTool, HostedToolSummary } from "./host.js";
-import type { AppOperation } from "./operations.js";
-/** Tool names include their queries./mutations. prefix. Resolution never requires listing. */
-export interface DynamicTools {
-    readonly list: () => Effect.Effect<readonly HostedTool[], unknown>;
-    readonly resolve: (name: string) => Effect.Effect<AppOperation | undefined, unknown>;
-    /** Names and descriptions without schemas. Omitted sources reduce list(). */
-    readonly summaries?: () => Effect.Effect<readonly HostedToolSummary[], unknown>;
-    /** One tool's full metadata without listing. Omitted sources search list(). */
-    readonly describe?: (name: string) => Effect.Effect<HostedTool | undefined, unknown>;
-}

package/types/apps/src/contracts/storage.d.ts

@@ -1,68 +0,0 @@
-/** Native app data boundary. Hosts bind a configured app before exposing this capability. */
-import { Schema, type Effect } from "effect";
-import type { RowMetadata, ReadTable, WriteTable } from "../../../app-data/src/index.js";
-import type { Fields, ObjectValue } from "../implementation/schema.js";
-import type { DatabaseSchema, DatabaseSession, AppDatabaseError } from "../../../app-data/src/contracts/database.js";
-/** Names for authored operations and tables. */
-export declare const StorageName: Schema.NonEmptyString;
-declare const AppStorageUnavailable_base: Schema.Class<AppStorageUnavailable, Schema.TaggedStruct<"AppStorageUnavailable", {}>, import("effect/Cause").YieldableError>;
-/** Storage is not configured on this host. */
-export declare class AppStorageUnavailable extends AppStorageUnavailable_base {
-}
-declare const AppStorageError_base: Schema.Class<AppStorageError, Schema.TaggedStruct<"AppStorageError", {}>, import("effect/Cause").YieldableError>;
-/** App storage operations never expose SQL, documents or credentials in failures. */
-export declare class AppStorageError extends AppStorageError_base {
-}
-/** The adapter owns the database connection and transaction for the whole authored invocation. */
-export interface AppStorage {
-    readonly read: <A, E>(schema: DatabaseSchema, work: (session: DatabaseSession) => Effect.Effect<A, E>) => Effect.Effect<A, E | AppDatabaseError | AppStorageUnavailable | AppStorageError>;
-    readonly mutate: <A, E>(schema: DatabaseSchema, work: (session: DatabaseSession) => Effect.Effect<A, E>) => Effect.Effect<A, E | AppDatabaseError | AppStorageUnavailable | AppStorageError>;
-}
-type InputValue<F extends Fields> = {
-    readonly [K in keyof F as F[K]["optionalValue"] extends true ? never : F[K] extends {
-        readonly hasDefault: true;
-    } ? never : K]: Exclude<import("../implementation/schema.js").Infer<F[K]>, undefined>;
-} & {
-    readonly [K in keyof F as F[K]["optionalValue"] extends true ? K : F[K] extends {
-        readonly hasDefault: true;
-    } ? K : never]?: Exclude<import("../implementation/schema.js").Infer<F[K]>, undefined> | (F[K]["optionalValue"] extends true ? null : F[K] extends {
-        readonly inputOptional: true;
-    } ? null : never) | undefined;
-};
-/** Typed table declaration; indexes refer only to authored or host metadata fields. */
-export interface Table<F extends Fields, Index extends string = never> {
-    readonly fields: F;
-    readonly indexes: ReadonlyArray<{
-        readonly name: string;
-        readonly fields: readonly string[];
-    }>;
-    readonly index: <Name extends string>(name: Name, fields: readonly [
-        (keyof F & string) | keyof typeof RowMetadata.Type,
-        ...((keyof F & string) | keyof typeof RowMetadata.Type)[]
-    ]) => Table<F, Index | Name>;
-}
-/** Structural table catalog accepted at the author boundary. */
-export type Tables = Readonly<Record<string, {
-    readonly fields: Fields;
-    readonly indexes: ReadonlyArray<{
-        readonly name: string;
-        readonly fields: readonly string[];
-    }>;
-}>>;
-/** Generated row metadata is read-only and unavailable on inserts. */
-export type RowOf<T extends Tables[string]> = ObjectValue<T["fields"]> & typeof RowMetadata.Type;
-type IndexOf<T> = T extends Table<Fields, infer I> ? I : string;
-/** Queries receive only read methods. */
-export type DatabaseReader<T extends Tables> = {
-    readonly [K in keyof T]: ReadTable<RowOf<T[K]>, IndexOf<T[K]>>;
-};
-/** Mutation methods stay inside one native SQLite transaction. */
-export type Database<T extends Tables> = {
-    readonly [K in keyof T]: WriteTable<RowOf<T[K]>, InputValue<T[K]["fields"]>, IndexOf<T[K]>>;
-};
-/** Pure database declaration shared by requirements and derived handler contexts. */
-export interface DatabaseDefinition<T extends Tables = Tables> {
-    readonly schema: DatabaseSchema;
-    readonly tables: T;
-}
-export {};

package/types/apps/src/implementation/account-operations.d.ts

@@ -1,151 +0,0 @@
-/** Combine account-bound protocol operations without changing their upstream inputs. */
-import { Effect, Schema } from "effect";
-import type { DynamicTools } from "../contracts/dynamic-tools.js";
-import type { AppOperation, OperationContext } from "../contracts/operations.js";
-import { type JsonValue } from "../contracts/schema.js";
-import { type Operation } from "./operations.js";
-type Operations = {
-    readonly queries?: Readonly<Record<string, Operation<JsonValue, unknown, "query", OperationContext>>>;
-    readonly dynamicTools?: DynamicTools;
-    readonly mutations?: Readonly<Record<string, Operation<JsonValue, unknown, "mutation", OperationContext>>>;
-};
-/**
- * Discover each selected account's protocol operations and combine matching names.
- * Calls take { accountId, input }; each branch retains its account's input schema,
- * credentials, approval and output validation. Empty selections expose no operations.
- * Discovery is sequential and cancellation follows the caller's signal.
- */
-export declare const accountOperations: <Account extends {
-    readonly id: string;
-}>(accounts: readonly Account[], discover: (account: Account) => Promise<Operations>, options: {
-    readonly signal: AbortSignal;
-}) => Promise<{
-    queries: {
-        [k: string]: Operation<{
-            readonly accountId: string;
-            readonly input: unknown;
-        }, unknown, "query", import("../index.js").AppContext>;
-    };
-    mutations: {
-        [k: string]: Operation<{
-            readonly accountId: string;
-            readonly input: unknown;
-        }, unknown, "mutation", import("../index.js").AppContext>;
-    };
-} | {
-    dynamicTools: {
-        list: () => Effect.Effect<{
-            readonly name: string;
-            readonly description: string;
-            readonly inputSchema: {
-                readonly [x: string]: Schema.Json;
-            };
-            readonly _meta?: {
-                readonly [x: string]: Schema.Json;
-            };
-            readonly title?: string;
-            readonly outputSchema?: {
-                readonly [x: string]: Schema.Json;
-            };
-            readonly annotations?: {
-                readonly title?: string;
-                readonly readOnlyHint?: boolean;
-                readonly destructiveHint?: boolean;
-                readonly idempotentHint?: boolean;
-                readonly openWorldHint?: boolean;
-            };
-            readonly schedules?: readonly {
-                readonly name: string;
-                readonly timing: {
-                    readonly kind: "interval";
-                    readonly milliseconds: number;
-                } | {
-                    readonly kind: "cron";
-                    readonly calendar: {
-                        readonly expression: string;
-                        readonly timezone: string;
-                    };
-                };
-                readonly input: Schema.Json;
-            }[];
-            readonly readOnly?: boolean;
-        }[], unknown, never>;
-        summaries: () => Effect.Effect<{
-            readonly name: string;
-            readonly description: string;
-            readonly title?: string;
-            readonly annotations?: {
-                readonly title?: string;
-                readonly readOnlyHint?: boolean;
-                readonly destructiveHint?: boolean;
-                readonly idempotentHint?: boolean;
-                readonly openWorldHint?: boolean;
-            };
-            readonly schedules?: readonly {
-                readonly name: string;
-                readonly timing: {
-                    readonly kind: "interval";
-                    readonly milliseconds: number;
-                } | {
-                    readonly kind: "cron";
-                    readonly calendar: {
-                        readonly expression: string;
-                        readonly timezone: string;
-                    };
-                };
-                readonly input: Schema.Json;
-            }[];
-            readonly readOnly?: boolean;
-        }[], unknown, never>;
-        describe: (name: string) => Effect.Effect<{
-            readonly name: string;
-            readonly description: string;
-            readonly inputSchema: {
-                readonly [x: string]: Schema.Json;
-            };
-            readonly _meta?: {
-                readonly [x: string]: Schema.Json;
-            };
-            readonly title?: string;
-            readonly outputSchema?: {
-                readonly [x: string]: Schema.Json;
-            };
-            readonly annotations?: {
-                readonly title?: string;
-                readonly readOnlyHint?: boolean;
-                readonly destructiveHint?: boolean;
-                readonly idempotentHint?: boolean;
-                readonly openWorldHint?: boolean;
-            };
-            readonly schedules?: readonly {
-                readonly name: string;
-                readonly timing: {
-                    readonly kind: "interval";
-                    readonly milliseconds: number;
-                } | {
-                    readonly kind: "cron";
-                    readonly calendar: {
-                        readonly expression: string;
-                        readonly timezone: string;
-                    };
-                };
-                readonly input: Schema.Json;
-            }[];
-            readonly readOnly?: boolean;
-        } | undefined, unknown, never>;
-        resolve: (name: string) => Effect.Effect<AppOperation<unknown, unknown> | undefined, unknown, never>;
-    };
-    queries: {
-        [k: string]: Operation<{
-            readonly accountId: string;
-            readonly input: unknown;
-        }, unknown, "query", import("../index.js").AppContext>;
-    };
-    mutations: {
-        [k: string]: Operation<{
-            readonly accountId: string;
-            readonly input: unknown;
-        }, unknown, "mutation", import("../index.js").AppContext>;
-    };
-}>;
-export {};

package/types/apps/src/implementation/dynamic-tools.d.ts

@@ -1,8 +0,0 @@
-import { HostedTool } from "../contracts/host.js";
-import type { DynamicTools } from "../contracts/dynamic-tools.js";
-import { type OperationDeclaration } from "./operations.js";
-/** Declare metadata discovery separately from executable resolution. Names are fully qualified. */
-export declare const dynamicTools: (source: {
-    readonly list: () => Promise<readonly HostedTool[]>;
-    readonly resolve: (name: string) => Promise<OperationDeclaration<"query" | "mutation"> | undefined>;
-}) => DynamicTools;

package/types/apps/src/implementation/storage.d.ts

@@ -1,13 +0,0 @@
-import { type DatabaseSession } from "../../../app-data/src/index.js";
-import { type AppStorage } from "../contracts/storage.js";
-import type { DatabaseDefinition, Database, Table, Tables } from "../contracts/storage.js";
-import { type Fields } from "./schema.js";
-export type { DatabaseDefinition, Database, DatabaseReader, Table, Tables, RowOf, } from "../contracts/storage.js";
-/** Declare scalar columns using the same schemas as operation inputs. */
-export declare const table: <const F extends Fields>(fields: F) => Table<F>;
-/** Build a fresh Promise database facade for one authorized invocation. */
-export declare const authorDatabase: <T extends Tables>(tables: T, session: DatabaseSession, signal: AbortSignal, writable: boolean) => Database<T>;
-/** Declare storage independently of handlers; the host binds each invocation's database. */
-export declare const defineDatabase: <const T extends Tables>(tables: T) => DatabaseDefinition<T>;
-/** Explicit missing capability, never a fallback to another app's data. */
-export declare const unavailableStorage: AppStorage;