apps 0.0.1-beta.34 → 0.0.1-beta.36

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

@@ -79,11 +79,16 @@ declare const SkillLoadFailed_base: Schema.Class<SkillLoadFailed, Schema.TaggedS
     readonly reason: Schema.Literals<readonly ["source", "request", "rate_limited", "document", "limit", "changed", "encoding"]>;
     readonly message: Schema.optional<Schema.String>;
     readonly status: Schema.optional<Schema.Int>;
+    readonly missing: Schema.optional<Schema.Literals<readonly ["repository", "ref"]>>;
 }>, import("effect/Cause").YieldableError>;
 /**
  * A skill loader failure shown to people. `message` is the explanation they read; write it for
  * them and never include URLs, tokens or response bodies. `reason` selects the title and whether
  * a retry can help. Custom loaders throw this error to get the same presentation as built-ins.
+ * With `source`, `missing` names what the service's answer points to as missing: the `repository`,
+ * or the branch or tag (`ref`). It may be missing, or not readable with the request's credentials.
+ * Without it, the source's settings or the paths it lists are not valid.
+ * These fields choose the explanation; they never show that the failure lies outside Executor.
  */
 export declare class SkillLoadFailed extends SkillLoadFailed_base {
 }

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

@@ -1,6 +1,6 @@
 /** Browser-to-host operations bind identity and authentication outside authored app code. */
 import { Schema } from "effect";
-import { HttpApi, HttpApiEndpoint, HttpApiGroup, HttpApiSchema } from "effect/unstable/httpapi";
+import { HttpApi, HttpApiEndpoint, HttpApiGroup, HttpApiSchema } from "effect/http-api";
 /** Non-secret page context injected by the serving host. */
 export declare const UiContext: Schema.Struct<{
     readonly deployment: Schema.NonEmptyString;

package/types/apps/src/implementation/failure-detail.d.ts

@@ -1,6 +1,5 @@
 import { Option, Redacted } from "effect";
-import type { ResolvedAccounts } from "../contracts/host.js";
-import { McpError } from "../contracts/mcp.js";
+import { McpError as HostMcpError, SkillLoadFailed as HostSkillLoadFailed, type ResolvedAccounts } from "../contracts/host.js";
 import type { ProviderError } from "../contracts/provider-error.js";
 import { type FailureFields, type FailurePhase, type UpstreamError } from "../contracts/failure.js";
 /** Fields of `FailureDetail` as constructor input. */
@@ -34,7 +33,9 @@ export declare const leavingProviderError: (error: ProviderError, secrets: reado
  * Rebuild an MCP failure's allowlisted fields, with account secrets replaced in the server's
  * error. Absent fields have no key, as catalogs cross the boundary as JSON values.
  */
-export declare const parseMcpError: (error: unknown, secrets: readonly string[]) => Option.Option<McpError>;
+export declare const parseMcpError: (error: unknown, secrets: readonly string[]) => Option.Option<HostMcpError>;
+/** Rebuild only the allowlisted skill loader fields from an author-visible rejection. */
+export declare const parseSkillLoadFailed: (error: unknown) => Option.Option<HostSkillLoadFailed>;
 /** `Name: message` for any thrown value, before redaction. */
 export declare const describeFailure: (error: unknown) => string;
 /**

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

@@ -1,4 +1,4 @@
-import { Atom } from "effect/unstable/reactivity";
+import { Atom } from "effect/reactivity";
 import { AppQueryFailed, type OperationReference, type QueryTransport } from "../contracts/live.js";
 import type { Operation } from "./operations.js";
 import { type Schema } from "./schema.js";
@@ -14,5 +14,5 @@ export declare const mutationReference: <Mutation>(name: Mutation extends Operat
 export declare const liveQueryAtom: <Input, Output>(reference: OperationReference<Input, Output, "query">, input: NoInfer<Input>, options: {
     readonly output: Schema<NoInfer<Output>, boolean>;
     readonly transport: QueryTransport;
-}) => Atom.Atom<import("effect/unstable/reactivity/AsyncResult").AsyncResult<NoInfer<Output>, import("effect/Cause").NoSuchElementError | AppQueryFailed>>;
+}) => Atom.Atom<import("effect/reactivity/AsyncResult").AsyncResult<NoInfer<Output>, import("effect/Cause").NoSuchElementError | AppQueryFailed>>;
 export {};

package/types/apps/src/implementation/mcp-client.d.ts

@@ -46,8 +46,8 @@ export declare function mcpClient(withClient: WithMcpClient, timeoutMs: number,
             readonly description?: string;
             readonly version?: string;
             readonly name?: string;
-            readonly title?: string;
             readonly instructions?: string;
+            readonly title?: string;
             readonly icons?: readonly {
                 readonly src: string;
                 readonly mimeType?: string;

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

@@ -30,8 +30,8 @@ export declare const mcpClientEffect: (input: McpToolsOptions, changed?: Effect.
             readonly description?: string;
             readonly version?: string;
             readonly name?: string;
-            readonly title?: string;
             readonly instructions?: string;
+            readonly title?: string;
             readonly icons?: readonly {
                 readonly src: string;
                 readonly mimeType?: string;

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

@@ -1,6 +1,6 @@
 /** Typed refusals and option checks for the fetch app code receives from the framework. */
 import { Effect } from "effect";
-import type { HttpClientResponse } from "effect/unstable/http";
+import type { HttpClientResponse } from "effect/http";
 import { type NetworkRefused } from "../contracts/network.js";
 type Fetch = (input: string | URL | Request, init?: RequestInit) => Promise<Response>;
 /** Fail with the refusal a protocol helper's response carries, or continue to its own handling. */

package/types/apps/src/implementation/openapi-compile.d.ts

@@ -68,7 +68,7 @@ export declare const compileOpenApiDocument: (entry: OpenApiImport, inputDocumen
         readonly input: {
             readonly [x: string]: Schema.Json;
         };
-        readonly method: "GET" | "POST" | "PUT" | "PATCH" | "DELETE" | "HEAD" | "OPTIONS" | "QUERY";
+        readonly method: "HEAD" | "GET" | "POST" | "PUT" | "PATCH" | "DELETE" | "OPTIONS" | "QUERY";
         readonly securitySchemes: {
             readonly [x: string]: {
                 readonly [x: string]: Schema.Json;

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

@@ -1,6 +1,6 @@
 /** One client's mounted queries and ordered optimistic write/read handoffs. */
 import { Effect } from "effect";
-import { Atom, AsyncResult } from "effect/unstable/reactivity";
+import { Atom, AsyncResult } from "effect/reactivity";
 import type { AppMutation } from "../contracts/optimistic.js";
 import type { OperationReference } from "../contracts/live.js";
 import { JsonValue } from "../contracts/schema.js";

package/types/apps/src/implementation/query-commit.d.ts

@@ -1,4 +1,4 @@
-import { AsyncResult } from "effect/unstable/reactivity";
+import { AsyncResult } from "effect/reactivity";
 /** Per-result metadata follows the exact Atom registry snapshot, including concurrent mounts. */
 export interface ObservedQueryValue<A> {
     readonly value: A;

package/types/apps/src/implementation/router-catalog.d.ts

@@ -6,7 +6,6 @@ import { Effect, Schema } from "effect";
 import { HostDeclarationInvalid, HostEvaluationFailed, type HostRouterError } from "../contracts/host.js";
 import type { AppOperation } from "../contracts/operations.js";
 import type { AppRouter, DynamicRouter, RouterMeta } from "../contracts/router.js";
-import { SkillLoadFailed } from "../contracts/skills.js";
 import type { OperationSchedule } from "../contracts/schedules.js";
 /**
  * Keep only a failure's safe fields. Anything unrecognized becomes an evaluation failure with the
@@ -189,7 +188,7 @@ export declare const readCatalog: (root: AppRouter | DynamicRouter | undefined,
     routers: {
         readonly path: string;
         readonly description?: string;
-        readonly error?: import("../index.js").ProviderError | SkillLoadFailed | HostDeclarationInvalid | HostEvaluationFailed | import("../mcp.js").McpError;
+        readonly error?: import("../index.js").ProviderError | HostDeclarationInvalid | HostEvaluationFailed | import("../contracts/host.js").McpError | import("../contracts/host.js").SkillLoadFailed;
         readonly title?: string;
         readonly tags?: {
             readonly [x: string]: string;
@@ -202,7 +201,7 @@ export declare const readCatalog: (root: AppRouter | DynamicRouter | undefined,
         }[];
         readonly skill?: string;
     }[];
-}, import("../index.js").ProviderError | SkillLoadFailed | HostDeclarationInvalid | HostEvaluationFailed | import("../mcp.js").McpError, never>;
+}, import("../index.js").ProviderError | HostDeclarationInvalid | HostEvaluationFailed | import("../contracts/host.js").McpError | import("../contracts/host.js").SkillLoadFailed, never>;
 /**
  * One skill for each router with instructions. Skills and tools fail independently: a dynamic
  * router whose metadata cannot be read, including the root, contributes no skill and does not

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

@@ -4,21 +4,21 @@ import { NetworkRefused } from "../contracts/network.js";
 import { ProviderError } from "../contracts/provider-error.js";
 import { AppSkills, SkillLoadFailed, type GitHubSkillsOptions, type WellKnownSkillsOptions, type SkillTransport } from "../contracts/skills.js";
 /** Give every failure without a message one that names the service. */
-export declare const withService: (service: string | undefined) => <A, R>(effect: Effect.Effect<A, SkillLoadFailed, R>) => Effect.Effect<A, SkillLoadFailed, R>;
+export declare const withService: (service: string | undefined) => <A, R>(effect: Effect.Effect<A, SkillLoadFailed | NetworkRefused, R>) => Effect.Effect<A, NetworkRefused | SkillLoadFailed, R>;
 interface ReadRequest {
     readonly headers?: Readonly<Record<string, string>>;
-    /** Describe a refusal by Executor's app network; defaults to the refusal's own message. */
-    readonly refused?: (refused: NetworkRefused) => SkillLoadFailed;
+    /** Describe a refusal by Executor's app network; defaults to the refusal itself. */
+    readonly refused?: (refused: NetworkRefused) => SkillLoadFailed | NetworkRefused;
 }
 /** One loader invocation owns its byte budget and all of its network requests. */
 export declare const reader: (transport: SkillTransport) => Effect.Effect<{
     fetchBytes: (url: string, request?: ReadRequest & {
         readonly body?: Uint8Array;
-    }) => Effect.Effect<Uint8Array<ArrayBuffer>, SkillLoadFailed, never>;
-    read: (url: string, request?: ReadRequest) => Effect.Effect<string, SkillLoadFailed, never>;
-    json: (url: string) => Effect.Effect<unknown, SkillLoadFailed, never>;
+    }) => Effect.Effect<Uint8Array<ArrayBuffer>, NetworkRefused | SkillLoadFailed, never>;
+    read: (url: string, request?: ReadRequest) => Effect.Effect<string, NetworkRefused | SkillLoadFailed, never>;
+    json: (url: string) => Effect.Effect<unknown, NetworkRefused | SkillLoadFailed, never>;
 }, never, never>;
-export declare const githubSkillsEffect: (options: GitHubSkillsOptions) => Effect.Effect<typeof AppSkills.Type, SkillLoadFailed | ProviderError>;
+export declare const githubSkillsEffect: (options: GitHubSkillsOptions) => Effect.Effect<typeof AppSkills.Type, SkillLoadFailed | NetworkRefused | ProviderError>;
 /** Fetch all indexed files and reject a publication whose index changes during the read. */
 export declare const wellKnownSkillsEffect: (options: WellKnownSkillsOptions) => Effect.Effect<readonly {
     readonly description: string;
@@ -33,5 +33,5 @@ export declare const wellKnownSkillsEffect: (options: WellKnownSkillsOptions) =>
         readonly [x: string]: string;
     };
     readonly "allowed-tools"?: string;
-}[], SkillLoadFailed, never>;
+}[], NetworkRefused | SkillLoadFailed, never>;
 export {};

package/types/apps/src/implementation/ui-auth.d.ts

@@ -1,5 +1,5 @@
 /** Host responses around app sign-in. They carry no script and never contain product credentials. */
-import { HttpServerResponse } from "effect/unstable/http";
+import { HttpServerResponse } from "effect/http";
 import { type AppSignInId } from "../contracts/ui-auth.js";
 /** Private app responses must not leak authentication URLs through caches or referrers. */
 export declare const appPrivateHeaders: {

package/types/apps/src/implementation/ui-client.d.ts

@@ -1,4 +1,4 @@
-import { AsyncResult, Atom } from "effect/unstable/reactivity";
+import { AsyncResult, Atom } from "effect/reactivity";
 import { type OperationReference } from "../contracts/live.js";
 import { type Schema } from "./schema.js";
 /** A scoped page client. Host-injected context carries only the deployment, never credentials. */

package/types/apps/src/implementation/ui-serving.d.ts

@@ -1,5 +1,5 @@
 import { Effect } from "effect";
-import { HttpServerRequest, HttpServerResponse } from "effect/unstable/http";
+import { HttpServerRequest, HttpServerResponse } from "effect/http";
 import { UiForbidden, type AppUiAsset, type UiAccountNotice } from "../contracts/ui.js";
 /**
  * Render an authorized deployment with a host-owned deployment watcher. Account problems that stop

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

@@ -1,4 +1,4 @@
-import { AsyncResult, type Atom } from "effect/unstable/reactivity";
+import { AsyncResult, type Atom } from "effect/reactivity";
 /** Subscribe for the component lifetime. Each mount owns and disposes its registry, including StrictMode remounts. */
 export declare const useAppQuery: <A, E>(atom: Atom.Atom<AsyncResult.AsyncResult<A, E>>) => {
     data: A | undefined;

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

@@ -66,7 +66,8 @@ export declare const folderSkills: (options: FolderSkillsOptions) => Promise<rea
 }[]>;
 /**
  * Read files for a custom remote skill loader, such as one for GitLab. Reads share one byte
- * budget and reject with the same safe SkillLoadFailed errors as githubSkills, naming `service`.
+ * budget and reject with the same safe SkillLoadFailed errors as githubSkills, naming `service`,
+ * or with `NetworkRefused` when Executor's network refuses a request.
  */
 export declare const skillReader: (options: SkillReaderOptions) => {
     /** Fetch one UTF-8 text file. */

package/types/telemetry/src/browser-operations.d.ts

@@ -1,6 +1,6 @@
 /** Correlate transport and decoded outcomes without exporting response bodies or errors. */
 import { Effect, Schema, Tracer } from "effect";
-import { HttpClient, HttpClientError } from "effect/unstable/http";
+import { HttpClient, HttpClientError } from "effect/http";
 /**
  * A random identity for the current browser document. It is never an authentication or user
  * identifier. Server renders have no document, so they get none instead of sharing one per isolate.

package/types/telemetry/src/browser.d.ts

@@ -1,7 +1,7 @@
 /** Browser-owned Effect telemetry, shared by Promise calls and Atom runtimes. */
 import { Context, Effect, Layer, ManagedRuntime } from "effect";
-import { OtlpExporter } from "effect/unstable/observability";
-import { Atom } from "effect/unstable/reactivity";
+import { OtlpExporter } from "effect/observability";
+import { Atom } from "effect/reactivity";
 import type { TelemetryConfig } from "./config.js";
 declare const BrowserTelemetry_base: Context.ServiceClass<BrowserTelemetry, "executor/BrowserTelemetry", {
     readonly navigation: (event: {

package/types/telemetry/src/layer.d.ts

@@ -2,6 +2,6 @@
 import { Layer, Logger } from "effect";
 import { type TelemetryConfig } from "./config.js";
 /** Build one tracer per runtime. Event mode defers export until Worker scope finalization. */
-export declare const telemetryLayer: (config: TelemetryConfig, lifetime?: "process" | "event", logger?: Logger.Logger<unknown, void>) => Layer.Layer<import("effect/unstable/observability/OtlpExporter").Flusher, never, never>;
+export declare const telemetryLayer: (config: TelemetryConfig, lifetime?: "process" | "event", logger?: Logger.Logger<unknown, void>) => Layer.Layer<import("effect/observability/OtlpExporter").Flusher, never, never>;
 /** Node/local entry points resolve telemetry once and share it for their process lifetime. */
-export declare const telemetryFromConfig: (service: string) => Layer.Layer<import("effect/unstable/observability/OtlpExporter").Flusher, import("effect/Schema").SchemaError | import("effect/Config").ConfigError, never>;
+export declare const telemetryFromConfig: (service: string) => Layer.Layer<import("effect/observability/OtlpExporter").Flusher, import("effect/Schema").SchemaError | import("effect/Config").ConfigError, never>;

package/types/telemetry/src/relay.d.ts

@@ -23,6 +23,6 @@ export declare const collectTelemetry: <A, E, R>(effect: Effect.Effect<A, E, R>)
         logs: string[];
         dropped: number;
     };
-}, E, Exclude<Exclude<R, import("effect/unstable/observability/OtlpExporter").Flusher>, never>>;
+}, E, Exclude<Exclude<R, import("effect/observability/OtlpExporter").Flusher>, never>>;
 /** Validate isolated records and export only this call's trace, using parent-owned credentials/identity. */
-export declare const forwardTelemetry: (batch: TelemetryBatch, traceId: string | undefined, build: string | undefined, service?: "executor-app" | "executor-web") => Effect.Effect<void, Schema.SchemaError | import("effect/unstable/http/HttpClientError").HttpClientError | import("effect/Cause").TimeoutError, never>;
+export declare const forwardTelemetry: (batch: TelemetryBatch, traceId: string | undefined, build: string | undefined, service?: "executor-app" | "executor-web") => Effect.Effect<void, Schema.SchemaError | import("effect/http/HttpClientError").HttpClientError | import("effect/Cause").TimeoutError, never>;

package/types/telemetry/src/transport.d.ts

@@ -1,5 +1,5 @@
 import { Context, Layer } from "effect";
-import { HttpClient } from "effect/unstable/http";
+import { HttpClient } from "effect/http";
 /** Local collector discovery can resolve its destination when an export runs. */
 export declare const CurrentTelemetryClient: Context.Reference<HttpClient.HttpClient | undefined>;
 /** Telemetry consumers inspect status and headers; release response I/O inside each export scope. */

package/types/utils/src/api-error.d.ts

@@ -1,5 +1,5 @@
 import { Schema, type Cause } from "effect";
-import "effect/unstable/httpapi";
+import "effect/http-api";
 /**
  * Encode the class's `message` getter as a required wire string. Decoding validates the field,
  * then omits it, so the class derives its own message from the parsed payload and a supplied