apps 0.0.1-beta.89 → 0.0.1-beta.90

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

@@ -1,23 +1,30 @@
 /** Ordinary async workflow declarations, adapted once into native Effect handlers. */
 import type { Schema as EffectSchema } from "effect";
 import type { AppWorkflow, WorkflowContext } from "../contracts/workflows.js";
+import type { AppRequirements } from "../contracts/context.js";
+import type { AccountScope } from "../contracts/app.js";
 import { type Schema } from "./schema.js";
 declare const NativeWorkflow: unique symbol;
+/**
+ * The context any workflow may declare: either scope, so a run started without a caller, such as
+ * by an app schedule, declares `WorkflowContext<typeof requirements, "app">`.
+ */
+export type AnyWorkflowContext = WorkflowContext<AppRequirements, AccountScope>;
 declare const HandlerContext: unique symbol;
 /** A workflow declaration retains input/output inference and required context compatibility. */
-export interface Workflow<Input, Output, Context extends WorkflowContext = WorkflowContext> {
+export interface Workflow<Input, Output, Context extends AnyWorkflowContext = WorkflowContext> {
     readonly [HandlerContext]?: (context: Context) => void;
     readonly [NativeWorkflow]: AppWorkflow<Input, Output>;
 }
 /** Composition view erases input only after retaining its runtime decoder. */
-export interface WorkflowDeclaration<Context extends WorkflowContext> {
+export interface WorkflowDeclaration<Context extends AnyWorkflowContext> {
     readonly [HandlerContext]?: (context: Context) => void;
     readonly [NativeWorkflow]: Omit<AppWorkflow<never>, "input"> & {
         readonly input: EffectSchema.Decoder<unknown>;
     };
 }
 /** Declare durable orchestration without starting a run or performing I/O. */
-export declare const workflow: <Input, Output, Context extends WorkflowContext = WorkflowContext>(options: {
+export declare const workflow: <Input, Output, Context extends AnyWorkflowContext = WorkflowContext>(options: {
     readonly input: Schema<Input, boolean>;
     readonly output?: Schema<Output, boolean>;
     readonly description?: string;

package/types/apps/src/index.d.ts

@@ -7,15 +7,16 @@ export { CacheError } from "../../app-cache/src/contracts/cache.js";
  * exposes ordinary declarations, schema helpers and Promise operations.
  */
 import { type Schema as EffectSchema } from "effect";
-import type { WebhookContext } from "./contracts/context.js";
+import type { AppRequirements, WebhookContext } from "./contracts/context.js";
+import type { AccountScope } from "./contracts/app.js";
 import { type JsonResponse as NativeResponse } from "./contracts/http.js";
 import { type OAuth2Config as NativeOAuth2Config, type OAuth2Method as NativeOAuth2Method, type ReservedAuthorizationParam, type SecretsMethod as NativeSecretsMethod } from "./contracts/provider.js";
 import type { Webhook as NativeWebhook } from "./contracts/webhooks.js";
 import { type PromiseMethods } from "./implementation/authoring.js";
 import { type PlacementInput, type RequestPlacements } from "./implementation/placement.js";
 import type { Placement } from "./contracts/placement.js";
-import type { AppContext as NativeAppContext, QueryContext as NativeQueryContext } from "./contracts/context.js";
-import { query as operationQuery, type OperationOptions } from "./implementation/operations.js";
+import type { QueryContext as NativeQueryContext } from "./contracts/context.js";
+import { query as operationQuery, type AnyContext, type OperationOptions } from "./implementation/operations.js";
 import { type Fields, type Infer, type ObjectSchema, type Schema, type SecretFields, type SecretObject } from "./implementation/schema.js";
 export { DeclarationInvalid, type DeclarationIssue, type JsonObject, type JsonValue, ValidationError, } from "./contracts/schema.js";
 export { type Fields, type Infer, type ObjectSchema, type ObjectValue, type Schema, array, boolean, json, jsonSchema, literal, number, object, record, string, plain, raw, type SecretString, } from "./implementation/schema.js";
@@ -75,8 +76,8 @@ export declare function oauth2<Response extends Schema<unknown, boolean>>(option
     readonly response: Response;
     readonly request?: RequestPlacements<FieldNameOf<Response>>;
 }): OAuth2Method<Response>;
-export type { AccountSlots } from "./contracts/app.js";
-export type { AppRequirements, AppContext, QueryContext, MutationContext, WebhookContext, } from "./contracts/context.js";
+export type { AccountScope, AccountSlots, WebhookAccount } from "./contracts/app.js";
+export type { AnyScopeMutationContext, AppRequirements, AppContext, QueryContext, MutationContext, WebhookContext, } from "./contracts/context.js";
 export { type App, type AppDefinition, defineApp } from "./implementation/app.js";
 export { event, type EventDeclaration, type EventEmitter } from "./implementation/events.js";
 export type { EmitOptions } from "./contracts/events.js";
@@ -86,7 +87,12 @@ type AuthorWebhook<Member, Config, State> = Member extends object ? Omit<Promise
     readonly state: State;
 } : never;
 /** Author lifecycle methods use async functions and share native decoded context/state types. */
-export type Webhook<Context extends WebhookContext, Config extends Schema<unknown, boolean>, State extends Schema<unknown, boolean>> = AuthorWebhook<NativeWebhook<Context, EffectSchema.Decoder<Infer<Config>>, EffectSchema.Decoder<Infer<State>>>, Config, State>;
+/**
+ * A webhook's context names its source account's scope: one with `user` serves a user requirement
+ * (`account: { user: "x" }`), one of the `"app"` scope an app requirement (`account: { app: "x" }`)
+ * and runs without a caller.
+ */
+export type Webhook<Context extends WebhookContext<AppRequirements, AccountScope>, Config extends Schema<unknown, boolean>, State extends Schema<unknown, boolean>> = AuthorWebhook<NativeWebhook<Context, EffectSchema.Decoder<Infer<Config>>, EffectSchema.Decoder<Infer<State>>>, Config, State>;
 export { ResponseDecodeError, ResponseStatusError } from "./contracts/http.js";
 /** Native fetch-compatible response accepted at the author boundary. */
 export type JsonResponse = PromiseMethods<NativeResponse>;
@@ -100,10 +106,10 @@ export type { Sql, SqlCursor, SqlReader, SqlRow, SqlTransaction, SqlValue, } fro
  * `request` places a credential in a query parameter, such as `query("key", key)`.
  */
 export declare function query(name: string, value: PlacementInput): Placement;
-export declare function query<Input, Output, Context extends NativeAppContext = NativeQueryContext>(options: OperationOptions<Input, Output>, run: (context: Context, input: Input) => Promise<Output>): ReturnType<typeof operationQuery<Input, Output, Context>>;
-export { mutation, withApproval, toolAnnotations, type Operation, type OperationOptions, } from "./implementation/operations.js";
+export declare function query<Input, Output, Context extends AnyContext = NativeQueryContext>(options: OperationOptions<Input, Output>, run: (context: Context, input: Input) => Promise<Output>): ReturnType<typeof operationQuery<Input, Output, Context>>;
+export { mutation, withApproval, toolAnnotations, type Approved, type Operation, type OperationOptions, } from "./implementation/operations.js";
 export type { OperationContext } from "./contracts/operations.js";
 export { workflow, type Workflow, type WorkflowDeclaration } from "./implementation/workflows.js";
 export { NonRetryableError, WorkflowFailure, type WorkflowContext, type WorkflowStepContext, type WorkflowStep, type WorkflowStepOptions, type WorkflowDuration, type WorkflowReads, type WorkflowControls, } from "./contracts/workflows.js";
-export { interval, cron, type ScheduleDeclaration } from "./implementation/schedules.js";
+export { appCron, appInterval, userCron, userInterval, type ScheduleDeclaration, } from "./implementation/schedules.js";
 export type { AppSkillSource as Skill, SkillFile } from "./contracts/skills.js";

package/js/chunk-F2G534HD.js

@@ -1,285 +0,0 @@
-import {
-  AccountId
-} from "./chunk-DDHBUKXX.js";
-import {
-  Schema_exports
-} from "./chunk-IFJU5SYQ.js";
-
-// src/contracts/failure.ts
-var maxFailureMessageLength = 2048;
-var FailureSource = Schema_exports.Literals(["app", "storage", "service"]);
-var FailureName = Schema_exports.String.check(Schema_exports.isMaxLength(128));
-var FailureCode = Schema_exports.String.check(Schema_exports.isMaxLength(128));
-var FailureMessage = Schema_exports.String.check(Schema_exports.isMaxLength(maxFailureMessageLength));
-var maxFailureFields = 8;
-var maxFailureFieldLength = 256;
-var FailureFieldName = Schema_exports.String.check(
-  Schema_exports.isPattern(/^[A-Za-z_$][A-Za-z0-9_$]{0,63}$/)
-);
-var FailureFieldValue = Schema_exports.Union([
-  Schema_exports.String.check(Schema_exports.isMaxLength(maxFailureFieldLength)),
-  Schema_exports.Finite,
-  Schema_exports.Boolean
-]);
-var FailureFields = Schema_exports.Record(FailureFieldName, FailureFieldValue).check(
-  Schema_exports.isMaxProperties(maxFailureFields)
-);
-var FailureDetail = {
-  source: Schema_exports.optionalKey(FailureSource),
-  errorName: Schema_exports.optionalKey(FailureName),
-  code: Schema_exports.optionalKey(FailureCode),
-  message: Schema_exports.optionalKey(FailureMessage),
-  fields: Schema_exports.optionalKey(FailureFields)
-};
-var maxUpstreamMessageLength = 1024;
-var UpstreamError = Schema_exports.Struct({
-  code: Schema_exports.Union([
-    Schema_exports.Int,
-    Schema_exports.String.check(Schema_exports.isMinLength(1), Schema_exports.isMaxLength(128))
-  ]),
-  message: Schema_exports.optionalKey(Schema_exports.String.check(Schema_exports.isMaxLength(maxUpstreamMessageLength)))
-});
-var FailurePhase = Schema_exports.Literals(["connect", "discover", "call"]);
-
-// 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),
-  phase: Schema_exports.optional(FailurePhase),
-  upstream: Schema_exports.optional(UpstreamError)
-}) {
-};
-
-// src/contracts/network.ts
-var NetworkRefusal = Schema_exports.Union([
-  Schema_exports.Struct({ reason: Schema_exports.Literal("private_address") }),
-  Schema_exports.Struct({
-    reason: Schema_exports.Literal("credential_host"),
-    /** The provider of the credential handle the request carried. */
-    provider: Schema_exports.String,
-    /** The hosts that provider's credentials may reach; empty when it declares none. */
-    allowedHosts: Schema_exports.Array(Schema_exports.String)
-  }),
-  Schema_exports.Struct({ reason: Schema_exports.Literal("credential_app") }),
-  Schema_exports.Struct({
-    reason: Schema_exports.Literal("credential_expired"),
-    /** The provider of the expired credential handle. */
-    provider: Schema_exports.String
-  }),
-  Schema_exports.Struct({
-    reason: Schema_exports.Literal("credential_placement"),
-    /** The provider of the misplaced credential handle. */
-    provider: Schema_exports.String,
-    /** Where the handle was found, such as `body` or `header x-note`. */
-    location: Schema_exports.String
-  }),
-  Schema_exports.Struct({
-    reason: Schema_exports.Literal("credential_transport"),
-    /** The provider of the credential handle the request carried. */
-    provider: Schema_exports.String
-  }),
-  Schema_exports.Struct({
-    reason: Schema_exports.Literal("credential_method"),
-    /** The refused HTTP method. */
-    method: Schema_exports.String
-  })
-]);
-var NetworkRefused = class extends Schema_exports.TaggedError()("NetworkRefused", {
-  /** The refused destination, with its port when the URL names one. */
-  host: Schema_exports.String,
-  refusal: NetworkRefusal
-}) {
-  get message() {
-    const refusal = this.refusal;
-    switch (refusal.reason) {
-      case "private_address":
-        return `Executor refused a request to ${this.host}: apps on this instance can reach only public addresses, and ${this.host} is a private, loopback or internal address. The request was not sent.`;
-      case "credential_host":
-        return refusal.allowedHosts.length === 0 ? `Executor refused this request: ${refusal.provider} credentials cannot be sent to ${this.host}: the provider declares no hosts.` : `Executor refused this request: ${refusal.provider} credentials cannot be sent to ${this.host}. The provider allows: ${refusal.allowedHosts.join(", ")}.`;
-      case "credential_app":
-        return "Executor refused this request: it carries a credential handle that is not valid for this app. Use the account fields this invocation received.";
-      case "credential_expired":
-        return `Executor refused this request: it carries an expired ${refusal.provider} credential handle. Use the account fields this invocation received.`;
-      case "credential_placement":
-        return `Executor refused this request: it carries a ${refusal.provider} credential handle in the ${refusal.location}, where the provider does not place it. Send credentials only as the provider's request declares, for example with the account's headers() and url().`;
-      case "credential_transport":
-        return `Executor refused this request: ${refusal.provider} credentials are sent only over HTTPS, and ${this.host} was requested over plain HTTP.`;
-      case "credential_method":
-        return `Executor refused this request: credential handles are never sent with ${refusal.method}, which asks the service to echo the request back.`;
-    }
-  }
-};
-var networkRefusalStatus = 421;
-var networkRefusalHeader = "x-executor-refused";
-var NetworkRefusedHeader = Schema_exports.StringFromUriComponent.pipe(
-  Schema_exports.decodeTo(Schema_exports.fromJsonString(NetworkRefused))
-);
-var encodeRefusal = Schema_exports.encodeSync(NetworkRefused);
-var encodeRefusalHeader = Schema_exports.encodeSync(NetworkRefusedHeader);
-var networkRefusalResponse = (refused) => new Response(JSON.stringify({ ...encodeRefusal(refused), message: refused.message }), {
-  status: networkRefusalStatus,
-  statusText: "Refused by Executor",
-  headers: {
-    "content-type": "application/json; charset=utf-8",
-    [networkRefusalHeader]: encodeRefusalHeader(refused)
-  }
-});
-var RestrictedFetchOption = Schema_exports.Literals(["redirect", "cache", "integrity"]);
-var supportedFetchOptions = {
-  redirect: ["follow", "manual"],
-  cache: ["no-store", "no-cache"],
-  integrity: [""]
-};
-var FetchOptionUnsupported = class extends Schema_exports.TaggedError()(
-  "FetchOptionUnsupported",
-  {
-    option: RestrictedFetchOption,
-    value: Schema_exports.String,
-    supported: Schema_exports.Array(Schema_exports.String)
-  }
-) {
-  get message() {
-    const supported = this.supported.map((value) => JSON.stringify(value)).join(" or ");
-    return `fetch option ${this.option}: ${JSON.stringify(this.value)} is not supported by Executor's app runtime. Use ${supported}, or omit ${this.option}.${this.advice}`;
-  }
-  /** What to do instead, when the standard value has an equivalent the runtime supports. */
-  get advice() {
-    switch (this.option) {
-      case "redirect":
-        return this.value === "error" ? ` To reject redirects, send redirect: "manual" and treat a 3xx response as the error.` : "";
-      case "cache":
-        return "";
-      case "integrity":
-        return " To check a digest, read the body and hash it with crypto.subtle.digest.";
-    }
-  }
-};
-
-// ../app-cache/src/contracts/cache.ts
-var CacheError = class extends Schema_exports.TaggedError()("CacheError", {
-  reason: Schema_exports.Literals(["unavailable", "storage", "invalid", "capacity", "timeout"]),
-  /** Which of `cacheLimits` the request exceeded, when one did. */
-  limit: Schema_exports.optionalKey(
-    Schema_exports.Literals([
-      "keyBytes",
-      "entryBytes",
-      "batchBytes",
-      "batchEntries",
-      "totalBytes",
-      "totalEntries"
-    ])
-  )
-}) {
-};
-var cacheLimits = {
-  keyBytes: 8192,
-  entryBytes: 2e6,
-  batchBytes: 8e6,
-  batchEntries: 128,
-  totalBytes: 128e6,
-  totalEntries: 1e5,
-  retentionMs: 7 * 24 * 60 * 60 * 1e3,
-  loadTimeoutMs: 9e4,
-  /**
-   * A loader's lease lapses this long after its host last renewed it. Hosts renew every
-   * `renewMs` while the invocation that claimed it runs, so a stalled or lost holder frees the
-   * key well inside an MCP execute budget.
-   */
-  leaseMs: 15e3,
-  renewMs: 5e3,
-  /** The longest a caller waits on another loader before loading for itself without publishing. */
-  waitMs: 1e4,
-  /** Bound for one command to a host store; a lost reply fails instead of holding its caller. */
-  commandTimeoutMs: 1e4
-};
-var Key = Schema_exports.String.check(Schema_exports.isPattern(/^[a-f0-9]{64}$/));
-var Time = Schema_exports.Finite.check(Schema_exports.isGreaterThanOrEqualTo(0));
-var CacheEntry = Schema_exports.Struct({
-  value: Schema_exports.Json,
-  version: Schema_exports.String,
-  freshUntil: Time,
-  staleUntil: Time
-});
-var CacheAcquired = Schema_exports.Struct({
-  entry: Schema_exports.NullOr(CacheEntry),
-  lease: Schema_exports.NullOr(Schema_exports.String),
-  /**
-   * The entries of the command's `reads`, in order, read in the same transaction as `entry`.
-   * Absent when the store did not read them: a store that predates them, or reads past the
-   * batch byte bound. The caller then reads them with a separate `read`.
-   */
-  reads: Schema_exports.optionalKey(Schema_exports.Array(Schema_exports.NullOr(CacheEntry)))
-});
-var CacheCommand = Schema_exports.Union([
-  Schema_exports.Struct({ operation: Schema_exports.Literal("read"), keys: Schema_exports.Array(Key) }),
-  Schema_exports.Struct({
-    operation: Schema_exports.Literal("acquire"),
-    key: Key,
-    /** Claim even a fresh entry, as an explicit refresh does. */
-    refresh: Schema_exports.Boolean,
-    /** Claim only while the entry still has this version. Absent accepts the current one. */
-    version: Schema_exports.optionalKey(Schema_exports.NullOr(Schema_exports.String)),
-    /**
-     * Other keys to read in the same transaction, as `read` would, so a caller that needs them
-     * beside the entry makes one round trip. Reading them claims and changes nothing.
-     */
-    reads: Schema_exports.optionalKey(Schema_exports.Array(Key))
-  }),
-  Schema_exports.Struct({
-    operation: Schema_exports.Literal("claim"),
-    key: Key,
-    version: Schema_exports.NullOr(Schema_exports.String)
-  }),
-  Schema_exports.Struct({
-    operation: Schema_exports.Literal("publish"),
-    key: Key,
-    lease: Schema_exports.String,
-    entry: CacheEntry
-  }),
-  Schema_exports.Struct({ operation: Schema_exports.Literal("release"), key: Key, lease: Schema_exports.String }),
-  /** Extend a lease its holder still owns. Replies false once the lease lapsed or was replaced. */
-  Schema_exports.Struct({ operation: Schema_exports.Literal("renew"), key: Key, lease: Schema_exports.String }),
-  Schema_exports.Struct({
-    operation: Schema_exports.Literal("write"),
-    entries: Schema_exports.Array(Schema_exports.Struct({ key: Key, entry: CacheEntry }))
-  }),
-  Schema_exports.Struct({ operation: Schema_exports.Literal("invalidate"), key: Key })
-]);
-var CacheReply = Schema_exports.Union([
-  Schema_exports.Struct({ ok: Schema_exports.Literal(true), value: Schema_exports.Json }),
-  Schema_exports.Struct({ ok: Schema_exports.Literal(false), error: CacheError })
-]);
-
-export {
-  maxFailureMessageLength,
-  FailureSource,
-  FailureName,
-  FailureCode,
-  FailureMessage,
-  maxFailureFields,
-  maxFailureFieldLength,
-  FailureFieldName,
-  FailureFieldValue,
-  FailureFields,
-  FailureDetail,
-  maxUpstreamMessageLength,
-  UpstreamError,
-  FailurePhase,
-  ProviderError,
-  NetworkRefusal,
-  NetworkRefused,
-  networkRefusalStatus,
-  networkRefusalHeader,
-  NetworkRefusedHeader,
-  networkRefusalResponse,
-  RestrictedFetchOption,
-  supportedFetchOptions,
-  FetchOptionUnsupported,
-  CacheError,
-  cacheLimits,
-  CacheEntry,
-  CacheAcquired,
-  CacheCommand,
-  CacheReply
-};