apps 0.0.1-beta.33 → 0.0.1-beta.35

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

@@ -1,6 +1,6 @@
 /** 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 type { SqlClient } from "effect/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: {

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

@@ -37,6 +37,20 @@ export interface AppCache {
         readonly id: string;
     }) => AppCache;
 }
+/**
+ * A credential a remote read sends, and the account it belongs to. A public source takes neither.
+ * A credential comes only with its account, so the read is cached in that account's scope.
+ */
+export type AccountCredential<Credential extends object> = ({
+    readonly account?: undefined;
+} & {
+    readonly [Field in keyof Credential]?: undefined;
+}) | ({
+    /** The selected account, as `accounts.<slot>` provides it. */
+    readonly account: {
+        readonly id: string;
+    };
+} & Credential);
 /** Trusted storage and background ownership; never accepted from request JSON. */
 export interface HostCache {
     readonly transport: CacheTransport;

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

@@ -1,6 +1,6 @@
 /** Shared MCP elicitation data. Delivery belongs to the host, independently of its transport. */
 import { Schema, type Effect } from "effect";
-import * as McpSchema from "effect/unstable/ai/McpSchema";
+import * as McpSchema from "effect/ai/McpSchema";
 import { type JsonValue } from "./schema.js";
 /** Maximum human-input wait, separate from active provider execution time. */
 export declare const ElicitationLimits: Schema.Struct<{
@@ -15,10 +15,10 @@ export declare const defaultElicitationLimits: {
 export declare const FormElicitation: Schema.Struct<{
     readonly mode: Schema.Literal<"form">;
     readonly requestedSchema: Schema.toEncoded<Schema.Struct<{
-        readonly $schema: Schema.decodeTo<Schema.optional<Schema.String>, Schema.optionalKey<Schema.String>, never, never>;
+        readonly $schema: Schema.decodeTo<Schema.toType<Schema.optional<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
         readonly type: Schema.tag<"object">;
         readonly properties: Schema.$Record<Schema.String, Schema.Union<readonly [Schema.Union<readonly [typeof McpSchema.LegacyTitledEnum, Schema.Union<readonly [typeof McpSchema.UntitledSingleSelectEnum, typeof McpSchema.TitledSingleSelectEnum]>, Schema.Union<readonly [typeof McpSchema.UntitledMultiSelectEnum, typeof McpSchema.TitledMultiSelectEnum]>]>, typeof McpSchema.ElicitationString, typeof McpSchema.ElicitationNumber, typeof McpSchema.ElicitationBoolean]>>;
-        readonly required: Schema.decodeTo<Schema.optional<Schema.$Array<Schema.String>>, Schema.optionalKey<Schema.$Array<Schema.String>>, never, never>;
+        readonly required: Schema.decodeTo<Schema.toType<Schema.optional<Schema.$Array<Schema.String>>>, Schema.optionalKey<Schema.$Array<Schema.String>>, never, never>;
     }>>;
     readonly _meta: Schema.optional<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
     readonly message: Schema.String;
@@ -28,7 +28,7 @@ export type FormElicitation = typeof FormElicitation.Type;
 export declare const ElicitationResponse: Schema.Union<readonly [Schema.Struct<{
     readonly _meta: Schema.optional<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
     readonly action: Schema.Literal<"accept">;
-    readonly content: Schema.decodeTo<Schema.optional<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean, Schema.$Array<Schema.String>]>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean, Schema.$Array<Schema.String>]>>>, never, never>;
+    readonly content: Schema.decodeTo<Schema.toType<Schema.optional<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean, Schema.$Array<Schema.String>]>>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean, Schema.$Array<Schema.String>]>>>, never, never>;
 }>, Schema.Struct<{
     readonly _meta: Schema.optional<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
     readonly action: Schema.Literals<readonly ["cancel", "decline"]>;
@@ -50,7 +50,7 @@ export declare const ElicitationReply: Schema.Union<readonly [Schema.Struct<{
     readonly response: Schema.Union<readonly [Schema.Struct<{
         readonly _meta: Schema.optional<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
         readonly action: Schema.Literal<"accept">;
-        readonly content: Schema.decodeTo<Schema.optional<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean, Schema.$Array<Schema.String>]>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean, Schema.$Array<Schema.String>]>>>, never, never>;
+        readonly content: Schema.decodeTo<Schema.toType<Schema.optional<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean, Schema.$Array<Schema.String>]>>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean, Schema.$Array<Schema.String>]>>>, never, never>;
     }>, Schema.Struct<{
         readonly _meta: Schema.optional<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
         readonly action: Schema.Literals<readonly ["cancel", "decline"]>;
@@ -75,7 +75,7 @@ export type ApprovalElicitation = typeof ApprovalElicitation.Type;
 export declare const ApprovalResponse: Schema.Union<readonly [Schema.Struct<{
     readonly _meta: Schema.optional<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
     readonly action: Schema.Literal<"accept">;
-    readonly content: Schema.decodeTo<Schema.optional<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean, Schema.$Array<Schema.String>]>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean, Schema.$Array<Schema.String>]>>>, never, never>;
+    readonly content: Schema.decodeTo<Schema.toType<Schema.optional<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean, Schema.$Array<Schema.String>]>>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean, Schema.$Array<Schema.String>]>>>, never, never>;
 }>, Schema.Struct<{
     readonly _meta: Schema.optional<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
     readonly action: Schema.Literals<readonly ["cancel", "decline"]>;

package/types/apps/src/contracts/protocols/1.d.ts

@@ -1625,10 +1625,10 @@ export declare const protocol1: {
         readonly elicitationRequest: Schema.Struct<{
             readonly mode: Schema.Literal<"form">;
             readonly requestedSchema: Schema.toEncoded<Schema.Struct<{
-                readonly $schema: Schema.decodeTo<Schema.optional<Schema.String>, Schema.optionalKey<Schema.String>, never, never>;
+                readonly $schema: Schema.decodeTo<Schema.toType<Schema.optional<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
                 readonly type: Schema.tag<"object">;
-                readonly properties: Schema.$Record<Schema.String, Schema.Union<readonly [Schema.Union<readonly [typeof import("effect/unstable/ai/McpSchema").LegacyTitledEnum, Schema.Union<readonly [typeof import("effect/unstable/ai/McpSchema").UntitledSingleSelectEnum, typeof import("effect/unstable/ai/McpSchema").TitledSingleSelectEnum]>, Schema.Union<readonly [typeof import("effect/unstable/ai/McpSchema").UntitledMultiSelectEnum, typeof import("effect/unstable/ai/McpSchema").TitledMultiSelectEnum]>]>, typeof import("effect/unstable/ai/McpSchema").ElicitationString, typeof import("effect/unstable/ai/McpSchema").ElicitationNumber, typeof import("effect/unstable/ai/McpSchema").ElicitationBoolean]>>;
-                readonly required: Schema.decodeTo<Schema.optional<Schema.$Array<Schema.String>>, Schema.optionalKey<Schema.$Array<Schema.String>>, never, never>;
+                readonly properties: Schema.$Record<Schema.String, Schema.Union<readonly [Schema.Union<readonly [typeof import("effect/ai/McpSchema").LegacyTitledEnum, Schema.Union<readonly [typeof import("effect/ai/McpSchema").UntitledSingleSelectEnum, typeof import("effect/ai/McpSchema").TitledSingleSelectEnum]>, Schema.Union<readonly [typeof import("effect/ai/McpSchema").UntitledMultiSelectEnum, typeof import("effect/ai/McpSchema").TitledMultiSelectEnum]>]>, typeof import("effect/ai/McpSchema").ElicitationString, typeof import("effect/ai/McpSchema").ElicitationNumber, typeof import("effect/ai/McpSchema").ElicitationBoolean]>>;
+                readonly required: Schema.decodeTo<Schema.toType<Schema.optional<Schema.$Array<Schema.String>>>, Schema.optionalKey<Schema.$Array<Schema.String>>, never, never>;
             }>>;
             readonly _meta: Schema.optional<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
             readonly message: Schema.String;
@@ -1638,7 +1638,7 @@ export declare const protocol1: {
             readonly response: Schema.Union<readonly [Schema.Struct<{
                 readonly _meta: Schema.optional<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
                 readonly action: Schema.Literal<"accept">;
-                readonly content: Schema.decodeTo<Schema.optional<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean, Schema.$Array<Schema.String>]>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean, Schema.$Array<Schema.String>]>>>, never, never>;
+                readonly content: Schema.decodeTo<Schema.toType<Schema.optional<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean, Schema.$Array<Schema.String>]>>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean, Schema.$Array<Schema.String>]>>>, never, never>;
             }>, Schema.Struct<{
                 readonly _meta: Schema.optional<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
                 readonly action: Schema.Literals<readonly ["cancel", "decline"]>;

package/types/apps/src/contracts/protocols/2.d.ts

@@ -579,10 +579,10 @@ export declare const protocol2: {
         readonly elicitationRequest: Schema.Struct<{
             readonly mode: Schema.Literal<"form">;
             readonly requestedSchema: Schema.toEncoded<Schema.Struct<{
-                readonly $schema: Schema.decodeTo<Schema.optional<Schema.String>, Schema.optionalKey<Schema.String>, never, never>;
+                readonly $schema: Schema.decodeTo<Schema.toType<Schema.optional<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
                 readonly type: Schema.tag<"object">;
-                readonly properties: Schema.$Record<Schema.String, Schema.Union<readonly [Schema.Union<readonly [typeof import("effect/unstable/ai/McpSchema").LegacyTitledEnum, Schema.Union<readonly [typeof import("effect/unstable/ai/McpSchema").UntitledSingleSelectEnum, typeof import("effect/unstable/ai/McpSchema").TitledSingleSelectEnum]>, Schema.Union<readonly [typeof import("effect/unstable/ai/McpSchema").UntitledMultiSelectEnum, typeof import("effect/unstable/ai/McpSchema").TitledMultiSelectEnum]>]>, typeof import("effect/unstable/ai/McpSchema").ElicitationString, typeof import("effect/unstable/ai/McpSchema").ElicitationNumber, typeof import("effect/unstable/ai/McpSchema").ElicitationBoolean]>>;
-                readonly required: Schema.decodeTo<Schema.optional<Schema.$Array<Schema.String>>, Schema.optionalKey<Schema.$Array<Schema.String>>, never, never>;
+                readonly properties: Schema.$Record<Schema.String, Schema.Union<readonly [Schema.Union<readonly [typeof import("effect/ai/McpSchema").LegacyTitledEnum, Schema.Union<readonly [typeof import("effect/ai/McpSchema").UntitledSingleSelectEnum, typeof import("effect/ai/McpSchema").TitledSingleSelectEnum]>, Schema.Union<readonly [typeof import("effect/ai/McpSchema").UntitledMultiSelectEnum, typeof import("effect/ai/McpSchema").TitledMultiSelectEnum]>]>, typeof import("effect/ai/McpSchema").ElicitationString, typeof import("effect/ai/McpSchema").ElicitationNumber, typeof import("effect/ai/McpSchema").ElicitationBoolean]>>;
+                readonly required: Schema.decodeTo<Schema.toType<Schema.optional<Schema.$Array<Schema.String>>>, Schema.optionalKey<Schema.$Array<Schema.String>>, never, never>;
             }>>;
             readonly _meta: Schema.optional<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
             readonly message: Schema.String;
@@ -592,7 +592,7 @@ export declare const protocol2: {
             readonly response: Schema.Union<readonly [Schema.Struct<{
                 readonly _meta: Schema.optional<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
                 readonly action: Schema.Literal<"accept">;
-                readonly content: Schema.decodeTo<Schema.optional<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean, Schema.$Array<Schema.String>]>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean, Schema.$Array<Schema.String>]>>>, never, never>;
+                readonly content: Schema.decodeTo<Schema.toType<Schema.optional<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean, Schema.$Array<Schema.String>]>>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean, Schema.$Array<Schema.String>]>>>, never, never>;
             }>, Schema.Struct<{
                 readonly _meta: Schema.optional<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
                 readonly action: Schema.Literals<readonly ["cancel", "decline"]>;

package/types/apps/src/contracts/protocols/3.d.ts

@@ -585,10 +585,10 @@ export declare const protocol3: {
         readonly elicitationRequest: Schema.Struct<{
             readonly mode: Schema.Literal<"form">;
             readonly requestedSchema: Schema.toEncoded<Schema.Struct<{
-                readonly $schema: Schema.decodeTo<Schema.optional<Schema.String>, Schema.optionalKey<Schema.String>, never, never>;
+                readonly $schema: Schema.decodeTo<Schema.toType<Schema.optional<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
                 readonly type: Schema.tag<"object">;
-                readonly properties: Schema.$Record<Schema.String, Schema.Union<readonly [Schema.Union<readonly [typeof import("effect/unstable/ai/McpSchema").LegacyTitledEnum, Schema.Union<readonly [typeof import("effect/unstable/ai/McpSchema").UntitledSingleSelectEnum, typeof import("effect/unstable/ai/McpSchema").TitledSingleSelectEnum]>, Schema.Union<readonly [typeof import("effect/unstable/ai/McpSchema").UntitledMultiSelectEnum, typeof import("effect/unstable/ai/McpSchema").TitledMultiSelectEnum]>]>, typeof import("effect/unstable/ai/McpSchema").ElicitationString, typeof import("effect/unstable/ai/McpSchema").ElicitationNumber, typeof import("effect/unstable/ai/McpSchema").ElicitationBoolean]>>;
-                readonly required: Schema.decodeTo<Schema.optional<Schema.$Array<Schema.String>>, Schema.optionalKey<Schema.$Array<Schema.String>>, never, never>;
+                readonly properties: Schema.$Record<Schema.String, Schema.Union<readonly [Schema.Union<readonly [typeof import("effect/ai/McpSchema").LegacyTitledEnum, Schema.Union<readonly [typeof import("effect/ai/McpSchema").UntitledSingleSelectEnum, typeof import("effect/ai/McpSchema").TitledSingleSelectEnum]>, Schema.Union<readonly [typeof import("effect/ai/McpSchema").UntitledMultiSelectEnum, typeof import("effect/ai/McpSchema").TitledMultiSelectEnum]>]>, typeof import("effect/ai/McpSchema").ElicitationString, typeof import("effect/ai/McpSchema").ElicitationNumber, typeof import("effect/ai/McpSchema").ElicitationBoolean]>>;
+                readonly required: Schema.decodeTo<Schema.toType<Schema.optional<Schema.$Array<Schema.String>>>, Schema.optionalKey<Schema.$Array<Schema.String>>, never, never>;
             }>>;
             readonly _meta: Schema.optional<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
             readonly message: Schema.String;
@@ -598,7 +598,7 @@ export declare const protocol3: {
             readonly response: Schema.Union<readonly [Schema.Struct<{
                 readonly _meta: Schema.optional<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
                 readonly action: Schema.Literal<"accept">;
-                readonly content: Schema.decodeTo<Schema.optional<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean, Schema.$Array<Schema.String>]>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean, Schema.$Array<Schema.String>]>>>, never, never>;
+                readonly content: Schema.decodeTo<Schema.toType<Schema.optional<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean, Schema.$Array<Schema.String>]>>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean, Schema.$Array<Schema.String>]>>>, never, never>;
             }>, Schema.Struct<{
                 readonly _meta: Schema.optional<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
                 readonly action: Schema.Literals<readonly ["cancel", "decline"]>;

package/types/apps/src/contracts/protocols/4.d.ts

@@ -1167,10 +1167,10 @@ export declare const protocol4: {
         readonly elicitationRequest: Schema.Struct<{
             readonly mode: Schema.Literal<"form">;
             readonly requestedSchema: Schema.toEncoded<Schema.Struct<{
-                readonly $schema: Schema.decodeTo<Schema.optional<Schema.String>, Schema.optionalKey<Schema.String>, never, never>;
+                readonly $schema: Schema.decodeTo<Schema.toType<Schema.optional<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
                 readonly type: Schema.tag<"object">;
-                readonly properties: Schema.$Record<Schema.String, Schema.Union<readonly [Schema.Union<readonly [typeof import("effect/unstable/ai/McpSchema").LegacyTitledEnum, Schema.Union<readonly [typeof import("effect/unstable/ai/McpSchema").UntitledSingleSelectEnum, typeof import("effect/unstable/ai/McpSchema").TitledSingleSelectEnum]>, Schema.Union<readonly [typeof import("effect/unstable/ai/McpSchema").UntitledMultiSelectEnum, typeof import("effect/unstable/ai/McpSchema").TitledMultiSelectEnum]>]>, typeof import("effect/unstable/ai/McpSchema").ElicitationString, typeof import("effect/unstable/ai/McpSchema").ElicitationNumber, typeof import("effect/unstable/ai/McpSchema").ElicitationBoolean]>>;
-                readonly required: Schema.decodeTo<Schema.optional<Schema.$Array<Schema.String>>, Schema.optionalKey<Schema.$Array<Schema.String>>, never, never>;
+                readonly properties: Schema.$Record<Schema.String, Schema.Union<readonly [Schema.Union<readonly [typeof import("effect/ai/McpSchema").LegacyTitledEnum, Schema.Union<readonly [typeof import("effect/ai/McpSchema").UntitledSingleSelectEnum, typeof import("effect/ai/McpSchema").TitledSingleSelectEnum]>, Schema.Union<readonly [typeof import("effect/ai/McpSchema").UntitledMultiSelectEnum, typeof import("effect/ai/McpSchema").TitledMultiSelectEnum]>]>, typeof import("effect/ai/McpSchema").ElicitationString, typeof import("effect/ai/McpSchema").ElicitationNumber, typeof import("effect/ai/McpSchema").ElicitationBoolean]>>;
+                readonly required: Schema.decodeTo<Schema.toType<Schema.optional<Schema.$Array<Schema.String>>>, Schema.optionalKey<Schema.$Array<Schema.String>>, never, never>;
             }>>;
             readonly _meta: Schema.optional<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
             readonly message: Schema.String;
@@ -1180,7 +1180,7 @@ export declare const protocol4: {
             readonly response: Schema.Union<readonly [Schema.Struct<{
                 readonly _meta: Schema.optional<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
                 readonly action: Schema.Literal<"accept">;
-                readonly content: Schema.decodeTo<Schema.optional<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean, Schema.$Array<Schema.String>]>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean, Schema.$Array<Schema.String>]>>>, never, never>;
+                readonly content: Schema.decodeTo<Schema.toType<Schema.optional<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean, Schema.$Array<Schema.String>]>>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean, Schema.$Array<Schema.String>]>>>, never, never>;
             }>, Schema.Struct<{
                 readonly _meta: Schema.optional<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
                 readonly action: Schema.Literals<readonly ["cancel", "decline"]>;

package/types/apps/src/contracts/protocols/5.d.ts

@@ -1043,10 +1043,10 @@ export declare const protocol5: {
         readonly elicitationRequest: Schema.Struct<{
             readonly mode: Schema.Literal<"form">;
             readonly requestedSchema: Schema.toEncoded<Schema.Struct<{
-                readonly $schema: Schema.decodeTo<Schema.optional<Schema.String>, Schema.optionalKey<Schema.String>, never, never>;
+                readonly $schema: Schema.decodeTo<Schema.toType<Schema.optional<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
                 readonly type: Schema.tag<"object">;
-                readonly properties: Schema.$Record<Schema.String, Schema.Union<readonly [Schema.Union<readonly [typeof import("effect/unstable/ai/McpSchema").LegacyTitledEnum, Schema.Union<readonly [typeof import("effect/unstable/ai/McpSchema").UntitledSingleSelectEnum, typeof import("effect/unstable/ai/McpSchema").TitledSingleSelectEnum]>, Schema.Union<readonly [typeof import("effect/unstable/ai/McpSchema").UntitledMultiSelectEnum, typeof import("effect/unstable/ai/McpSchema").TitledMultiSelectEnum]>]>, typeof import("effect/unstable/ai/McpSchema").ElicitationString, typeof import("effect/unstable/ai/McpSchema").ElicitationNumber, typeof import("effect/unstable/ai/McpSchema").ElicitationBoolean]>>;
-                readonly required: Schema.decodeTo<Schema.optional<Schema.$Array<Schema.String>>, Schema.optionalKey<Schema.$Array<Schema.String>>, never, never>;
+                readonly properties: Schema.$Record<Schema.String, Schema.Union<readonly [Schema.Union<readonly [typeof import("effect/ai/McpSchema").LegacyTitledEnum, Schema.Union<readonly [typeof import("effect/ai/McpSchema").UntitledSingleSelectEnum, typeof import("effect/ai/McpSchema").TitledSingleSelectEnum]>, Schema.Union<readonly [typeof import("effect/ai/McpSchema").UntitledMultiSelectEnum, typeof import("effect/ai/McpSchema").TitledMultiSelectEnum]>]>, typeof import("effect/ai/McpSchema").ElicitationString, typeof import("effect/ai/McpSchema").ElicitationNumber, typeof import("effect/ai/McpSchema").ElicitationBoolean]>>;
+                readonly required: Schema.decodeTo<Schema.toType<Schema.optional<Schema.$Array<Schema.String>>>, Schema.optionalKey<Schema.$Array<Schema.String>>, never, never>;
             }>>;
             readonly _meta: Schema.optional<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
             readonly message: Schema.String;
@@ -1056,7 +1056,7 @@ export declare const protocol5: {
             readonly response: Schema.Union<readonly [Schema.Struct<{
                 readonly _meta: Schema.optional<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
                 readonly action: Schema.Literal<"accept">;
-                readonly content: Schema.decodeTo<Schema.optional<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean, Schema.$Array<Schema.String>]>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean, Schema.$Array<Schema.String>]>>>, never, never>;
+                readonly content: Schema.decodeTo<Schema.toType<Schema.optional<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean, Schema.$Array<Schema.String>]>>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean, Schema.$Array<Schema.String>]>>>, never, never>;
             }>, Schema.Struct<{
                 readonly _meta: Schema.optional<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
                 readonly action: Schema.Literals<readonly ["cancel", "decline"]>;

package/types/apps/src/contracts/protocols/6.d.ts

@@ -1489,10 +1489,10 @@ export declare const protocol6: {
         readonly elicitationRequest: Schema.Struct<{
             readonly mode: Schema.Literal<"form">;
             readonly requestedSchema: Schema.toEncoded<Schema.Struct<{
-                readonly $schema: Schema.decodeTo<Schema.optional<Schema.String>, Schema.optionalKey<Schema.String>, never, never>;
+                readonly $schema: Schema.decodeTo<Schema.toType<Schema.optional<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
                 readonly type: Schema.tag<"object">;
-                readonly properties: Schema.$Record<Schema.String, Schema.Union<readonly [Schema.Union<readonly [typeof import("effect/unstable/ai/McpSchema").LegacyTitledEnum, Schema.Union<readonly [typeof import("effect/unstable/ai/McpSchema").UntitledSingleSelectEnum, typeof import("effect/unstable/ai/McpSchema").TitledSingleSelectEnum]>, Schema.Union<readonly [typeof import("effect/unstable/ai/McpSchema").UntitledMultiSelectEnum, typeof import("effect/unstable/ai/McpSchema").TitledMultiSelectEnum]>]>, typeof import("effect/unstable/ai/McpSchema").ElicitationString, typeof import("effect/unstable/ai/McpSchema").ElicitationNumber, typeof import("effect/unstable/ai/McpSchema").ElicitationBoolean]>>;
-                readonly required: Schema.decodeTo<Schema.optional<Schema.$Array<Schema.String>>, Schema.optionalKey<Schema.$Array<Schema.String>>, never, never>;
+                readonly properties: Schema.$Record<Schema.String, Schema.Union<readonly [Schema.Union<readonly [typeof import("effect/ai/McpSchema").LegacyTitledEnum, Schema.Union<readonly [typeof import("effect/ai/McpSchema").UntitledSingleSelectEnum, typeof import("effect/ai/McpSchema").TitledSingleSelectEnum]>, Schema.Union<readonly [typeof import("effect/ai/McpSchema").UntitledMultiSelectEnum, typeof import("effect/ai/McpSchema").TitledMultiSelectEnum]>]>, typeof import("effect/ai/McpSchema").ElicitationString, typeof import("effect/ai/McpSchema").ElicitationNumber, typeof import("effect/ai/McpSchema").ElicitationBoolean]>>;
+                readonly required: Schema.decodeTo<Schema.toType<Schema.optional<Schema.$Array<Schema.String>>>, Schema.optionalKey<Schema.$Array<Schema.String>>, never, never>;
             }>>;
             readonly _meta: Schema.optional<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
             readonly message: Schema.String;
@@ -1502,7 +1502,7 @@ export declare const protocol6: {
             readonly response: Schema.Union<readonly [Schema.Struct<{
                 readonly _meta: Schema.optional<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
                 readonly action: Schema.Literal<"accept">;
-                readonly content: Schema.decodeTo<Schema.optional<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean, Schema.$Array<Schema.String>]>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean, Schema.$Array<Schema.String>]>>>, never, never>;
+                readonly content: Schema.decodeTo<Schema.toType<Schema.optional<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean, Schema.$Array<Schema.String>]>>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean, Schema.$Array<Schema.String>]>>>, never, never>;
             }>, Schema.Struct<{
                 readonly _meta: Schema.optional<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
                 readonly action: Schema.Literals<readonly ["cancel", "decline"]>;

package/types/apps/src/contracts/protocols/7.d.ts

@@ -1653,10 +1653,10 @@ export declare const protocol7: {
         readonly elicitationRequest: Schema.Struct<{
             readonly mode: Schema.Literal<"form">;
             readonly requestedSchema: Schema.toEncoded<Schema.Struct<{
-                readonly $schema: Schema.decodeTo<Schema.optional<Schema.String>, Schema.optionalKey<Schema.String>, never, never>;
+                readonly $schema: Schema.decodeTo<Schema.toType<Schema.optional<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
                 readonly type: Schema.tag<"object">;
-                readonly properties: Schema.$Record<Schema.String, Schema.Union<readonly [Schema.Union<readonly [typeof import("effect/unstable/ai/McpSchema").LegacyTitledEnum, Schema.Union<readonly [typeof import("effect/unstable/ai/McpSchema").UntitledSingleSelectEnum, typeof import("effect/unstable/ai/McpSchema").TitledSingleSelectEnum]>, Schema.Union<readonly [typeof import("effect/unstable/ai/McpSchema").UntitledMultiSelectEnum, typeof import("effect/unstable/ai/McpSchema").TitledMultiSelectEnum]>]>, typeof import("effect/unstable/ai/McpSchema").ElicitationString, typeof import("effect/unstable/ai/McpSchema").ElicitationNumber, typeof import("effect/unstable/ai/McpSchema").ElicitationBoolean]>>;
-                readonly required: Schema.decodeTo<Schema.optional<Schema.$Array<Schema.String>>, Schema.optionalKey<Schema.$Array<Schema.String>>, never, never>;
+                readonly properties: Schema.$Record<Schema.String, Schema.Union<readonly [Schema.Union<readonly [typeof import("effect/ai/McpSchema").LegacyTitledEnum, Schema.Union<readonly [typeof import("effect/ai/McpSchema").UntitledSingleSelectEnum, typeof import("effect/ai/McpSchema").TitledSingleSelectEnum]>, Schema.Union<readonly [typeof import("effect/ai/McpSchema").UntitledMultiSelectEnum, typeof import("effect/ai/McpSchema").TitledMultiSelectEnum]>]>, typeof import("effect/ai/McpSchema").ElicitationString, typeof import("effect/ai/McpSchema").ElicitationNumber, typeof import("effect/ai/McpSchema").ElicitationBoolean]>>;
+                readonly required: Schema.decodeTo<Schema.toType<Schema.optional<Schema.$Array<Schema.String>>>, Schema.optionalKey<Schema.$Array<Schema.String>>, never, never>;
             }>>;
             readonly _meta: Schema.optional<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
             readonly message: Schema.String;
@@ -1666,7 +1666,7 @@ export declare const protocol7: {
             readonly response: Schema.Union<readonly [Schema.Struct<{
                 readonly _meta: Schema.optional<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
                 readonly action: Schema.Literal<"accept">;
-                readonly content: Schema.decodeTo<Schema.optional<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean, Schema.$Array<Schema.String>]>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean, Schema.$Array<Schema.String>]>>>, never, never>;
+                readonly content: Schema.decodeTo<Schema.toType<Schema.optional<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean, Schema.$Array<Schema.String>]>>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean, Schema.$Array<Schema.String>]>>>, never, never>;
             }>, Schema.Struct<{
                 readonly _meta: Schema.optional<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
                 readonly action: Schema.Literals<readonly ["cancel", "decline"]>;

package/types/apps/src/contracts/protocols/8.d.ts

@@ -988,10 +988,10 @@ export declare const protocol8: {
         readonly elicitationRequest: Schema.Struct<{
             readonly mode: Schema.Literal<"form">;
             readonly requestedSchema: Schema.toEncoded<Schema.Struct<{
-                readonly $schema: Schema.decodeTo<Schema.optional<Schema.String>, Schema.optionalKey<Schema.String>, never, never>;
+                readonly $schema: Schema.decodeTo<Schema.toType<Schema.optional<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
                 readonly type: Schema.tag<"object">;
-                readonly properties: Schema.$Record<Schema.String, Schema.Union<readonly [Schema.Union<readonly [typeof import("effect/unstable/ai/McpSchema").LegacyTitledEnum, Schema.Union<readonly [typeof import("effect/unstable/ai/McpSchema").UntitledSingleSelectEnum, typeof import("effect/unstable/ai/McpSchema").TitledSingleSelectEnum]>, Schema.Union<readonly [typeof import("effect/unstable/ai/McpSchema").UntitledMultiSelectEnum, typeof import("effect/unstable/ai/McpSchema").TitledMultiSelectEnum]>]>, typeof import("effect/unstable/ai/McpSchema").ElicitationString, typeof import("effect/unstable/ai/McpSchema").ElicitationNumber, typeof import("effect/unstable/ai/McpSchema").ElicitationBoolean]>>;
-                readonly required: Schema.decodeTo<Schema.optional<Schema.$Array<Schema.String>>, Schema.optionalKey<Schema.$Array<Schema.String>>, never, never>;
+                readonly properties: Schema.$Record<Schema.String, Schema.Union<readonly [Schema.Union<readonly [typeof import("effect/ai/McpSchema").LegacyTitledEnum, Schema.Union<readonly [typeof import("effect/ai/McpSchema").UntitledSingleSelectEnum, typeof import("effect/ai/McpSchema").TitledSingleSelectEnum]>, Schema.Union<readonly [typeof import("effect/ai/McpSchema").UntitledMultiSelectEnum, typeof import("effect/ai/McpSchema").TitledMultiSelectEnum]>]>, typeof import("effect/ai/McpSchema").ElicitationString, typeof import("effect/ai/McpSchema").ElicitationNumber, typeof import("effect/ai/McpSchema").ElicitationBoolean]>>;
+                readonly required: Schema.decodeTo<Schema.toType<Schema.optional<Schema.$Array<Schema.String>>>, Schema.optionalKey<Schema.$Array<Schema.String>>, never, never>;
             }>>;
             readonly _meta: Schema.optional<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
             readonly message: Schema.String;
@@ -1001,7 +1001,7 @@ export declare const protocol8: {
             readonly response: Schema.Union<readonly [Schema.Struct<{
                 readonly _meta: Schema.optional<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
                 readonly action: Schema.Literal<"accept">;
-                readonly content: Schema.decodeTo<Schema.optional<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean, Schema.$Array<Schema.String>]>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean, Schema.$Array<Schema.String>]>>>, never, never>;
+                readonly content: Schema.decodeTo<Schema.toType<Schema.optional<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean, Schema.$Array<Schema.String>]>>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean, Schema.$Array<Schema.String>]>>>, never, never>;
             }>, Schema.Struct<{
                 readonly _meta: Schema.optional<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
                 readonly action: Schema.Literals<readonly ["cancel", "decline"]>;

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

@@ -115,14 +115,26 @@ export interface SkillCacheOptions {
     readonly staleFor?: import("effect").Duration.Input;
 }
 /**
- * A public GitHub repository and an optional immutable commit, tag or branch. With a cache, a
- * branch or tag is resolved again when the catalog refreshes, and each commit's file list is kept.
+ * Whose access reads the repository. A public repository needs neither field. A private one takes
+ * a GitHub account and its token, sent on every request of this read. The token comes only with
+ * its account, so the catalog is cached in that account's scope and failures name the account.
  */
-export interface GitHubSkillsOptions extends SkillTransport, SkillCacheOptions {
+export type GitHubSkillsAccount = import("./cache.js").AccountCredential<{
+    /**
+     * The account's token or its handle, such as `account.fields.token`. Its provider declares
+     * hosts `github.com` and `raw.githubusercontent.com`, so app code never holds the value.
+     */
+    readonly token: string;
+}>;
+/**
+ * A GitHub repository and an optional immutable commit, tag or branch. With a cache, a branch or
+ * tag is resolved again when the catalog refreshes, and each commit's file list is kept.
+ */
+export type GitHubSkillsOptions = SkillTransport & SkillCacheOptions & GitHubSkillsAccount & {
     readonly repo: string;
     readonly path?: string;
     readonly ref?: string;
-}
+};
 /** A published directory index, including its listed skill documents and text references. */
 export interface WellKnownSkillsOptions extends SkillTransport, SkillCacheOptions {
     readonly url: string;

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/catalog-cache.d.ts

@@ -1,5 +1,5 @@
 import { Duration, Effect, Schema } from "effect";
-import type { AppCache, CacheLoadContext } from "../contracts/cache.js";
+import type { AccountCredential, AppCache, CacheLoadContext } from "../contracts/cache.js";
 import { JsonObject, type JsonValue } from "../contracts/schema.js";
 export interface CatalogCacheOptions {
     /** The app's cache. An account's catalog is kept in that account's scope. */
@@ -11,27 +11,24 @@ export interface CatalogCacheOptions {
     /** Await a fresh revision at an explicit logical connection or refresh boundary. */
     readonly revalidate?: boolean;
 }
-/**
- * Whose catalog a remote router reads. A public server takes neither field. Credential headers
- * come only with the account they belong to, so an authenticated catalog always has its account.
- */
-export type CatalogAccount = {
-    readonly account?: undefined;
-    readonly headers?: undefined;
-} | {
-    /** The selected account, as `accounts.<slot>` provides it. */
-    readonly account: {
-        readonly id: string;
-    };
+/** Whose catalog a remote router reads, and the headers, such as credentials, it sends. */
+export type CatalogAccount = AccountCredential<{
     /** Headers for this account's requests, such as its credentials. */
     readonly headers?: Readonly<Record<string, string>>;
-};
+}>;
+/** Why a read cannot use its account's scope. */
+export type CatalogScopeProblem = "missing-account" | "unselected-account";
 /**
  * The cache an account's catalog lives in: the account's own scope, which token renewals keep.
- * Credentials never enter a key. Headers without an account, or an account the app was not
- * given, fail with `invalid`.
+ * `credential` is what the read sends, such as headers or a token; it never enters a key. A
+ * credential without an account, or an account the app was not given, fails with `invalid`.
  */
-export declare const catalogScope: <E>(options: CatalogCacheOptions & CatalogAccount, invalid: () => E) => Effect.Effect<AppCache | undefined, E>;
+export declare const catalogScope: <E>(options: {
+    readonly cache?: AppCache | undefined;
+    readonly account?: {
+        readonly id: string;
+    } | undefined;
+}, credential: unknown, invalid: (problem: CatalogScopeProblem) => E) => Effect.Effect<AppCache | undefined, E>;
 /** One load: the tools, and optionally a record describing the whole catalog. */
 export interface CatalogLoad<A> {
     readonly tools: readonly A[];

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/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/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/skills.d.ts

@@ -1,31 +1,24 @@
 /** Remote skill readers return complete portable bundles, never installed host files. */
 import { Effect } from "effect";
-import { SkillLoadFailed, type GitHubSkillsOptions, type WellKnownSkillsOptions, type SkillTransport } from "../contracts/skills.js";
+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>;
+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;
+}
 /** One loader invocation owns its byte budget and all of its network requests. */
 export declare const reader: (transport: SkillTransport) => Effect.Effect<{
-    fetchBytes: (url: string, post?: {
-        readonly body: Uint8Array;
-        readonly headers: Record<string, string>;
+    fetchBytes: (url: string, request?: ReadRequest & {
+        readonly body?: Uint8Array;
     }) => Effect.Effect<Uint8Array<ArrayBuffer>, SkillLoadFailed, never>;
-    read: (url: string) => Effect.Effect<string, SkillLoadFailed, never>;
+    read: (url: string, request?: ReadRequest) => Effect.Effect<string, SkillLoadFailed, never>;
     json: (url: string) => Effect.Effect<unknown, SkillLoadFailed, never>;
 }, never, never>;
-export declare const githubSkillsEffect: (options: GitHubSkillsOptions) => Effect.Effect<readonly {
-    readonly description: string;
-    readonly name: string;
-    readonly files: readonly {
-        readonly path: string;
-        readonly content: string;
-    }[];
-    readonly license?: string;
-    readonly compatibility?: string;
-    readonly metadata?: {
-        readonly [x: string]: string;
-    };
-    readonly "allowed-tools"?: string;
-}[], SkillLoadFailed, never>;
+export declare const githubSkillsEffect: (options: GitHubSkillsOptions) => Effect.Effect<typeof AppSkills.Type, SkillLoadFailed | 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;
@@ -41,3 +34,4 @@ export declare const wellKnownSkillsEffect: (options: WellKnownSkillsOptions) =>
     };
     readonly "allowed-tools"?: string;
 }[], 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

@@ -1,8 +1,9 @@
 import { type FolderSkillsOptions, type GitHubSkillsOptions, type SkillReaderOptions, type WellKnownSkillsOptions, type SkillFile } from "./contracts/skills.js";
-export { SkillLoadFailed, SkillDefinitionInvalid, SkillServiceName, type SkillReaderOptions, type FolderSkillsOptions, type AppSkillSource as Skill, type SkillFile, type GitHubSkillsOptions, type SkillCacheOptions, type WellKnownSkillsOptions, } from "./contracts/skills.js";
+export { SkillLoadFailed, SkillDefinitionInvalid, SkillServiceName, type SkillReaderOptions, type FolderSkillsOptions, type AppSkillSource as Skill, type SkillFile, type GitHubSkillsAccount, type GitHubSkillsOptions, type SkillCacheOptions, type WellKnownSkillsOptions, } from "./contracts/skills.js";
 /**
- * Fetch a public GitHub skill collection from one resolved commit. Pass `cache: ctx.cache` to reuse
- * the catalog; without it, mutable refs resolve again on each call.
+ * Fetch a GitHub skill collection from one resolved commit. A private repository takes `account`
+ * and its `token`. Pass `cache: ctx.cache` to reuse the catalog; without it, mutable refs resolve
+ * again on each call.
  */
 export declare const githubSkills: (options: GitHubSkillsOptions) => Promise<readonly {
     readonly description: string;

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. */