apps 0.0.1-beta.67 → 0.0.1-beta.69

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

@@ -12,6 +12,14 @@ import { Schema } from "effect";
  *   the destination host.
  * - `credential_app`: the request carries a credential handle that is not valid for this app.
  * - `credential_expired`: the request carries an expired credential handle.
+ * - `credential_placement`: the request carries a credential handle somewhere its method does not
+ *   place it, such as a body, the URL path or another header, or in a value that does not match
+ *   the method's template exactly.
+ * - `credential_transport`: the request would send a placed credential over plain HTTP. Placed
+ *   credentials go only over HTTPS, except to a loopback address on an instance whose operator
+ *   lets apps reach private addresses, for local development.
+ * - `credential_method`: the request carries a credential handle and uses a method that asks the
+ *   service to echo the request back, such as `TRACE`.
  */
 export declare const NetworkRefusal: Schema.Union<readonly [Schema.Struct<{
     readonly reason: Schema.Literal<"private_address">;
@@ -27,6 +35,20 @@ export declare const NetworkRefusal: Schema.Union<readonly [Schema.Struct<{
     readonly reason: Schema.Literal<"credential_expired">;
     /** The provider of the expired credential handle. */
     readonly provider: Schema.String;
+}>, Schema.Struct<{
+    readonly reason: Schema.Literal<"credential_placement">;
+    /** The provider of the misplaced credential handle. */
+    readonly provider: Schema.String;
+    /** Where the handle was found, such as `body` or `header x-note`. */
+    readonly location: Schema.String;
+}>, Schema.Struct<{
+    readonly reason: Schema.Literal<"credential_transport">;
+    /** The provider of the credential handle the request carried. */
+    readonly provider: Schema.String;
+}>, Schema.Struct<{
+    readonly reason: Schema.Literal<"credential_method">;
+    /** The refused HTTP method. */
+    readonly method: Schema.String;
 }>]>;
 export type NetworkRefusal = typeof NetworkRefusal.Type;
 declare const NetworkRefused_base: Schema.Class<NetworkRefused, Schema.TaggedStruct<"NetworkRefused", {
@@ -46,6 +68,20 @@ declare const NetworkRefused_base: Schema.Class<NetworkRefused, Schema.TaggedStr
         readonly reason: Schema.Literal<"credential_expired">;
         /** The provider of the expired credential handle. */
         readonly provider: Schema.String;
+    }>, Schema.Struct<{
+        readonly reason: Schema.Literal<"credential_placement">;
+        /** The provider of the misplaced credential handle. */
+        readonly provider: Schema.String;
+        /** Where the handle was found, such as `body` or `header x-note`. */
+        readonly location: Schema.String;
+    }>, Schema.Struct<{
+        readonly reason: Schema.Literal<"credential_transport">;
+        /** The provider of the credential handle the request carried. */
+        readonly provider: Schema.String;
+    }>, Schema.Struct<{
+        readonly reason: Schema.Literal<"credential_method">;
+        /** The refused HTTP method. */
+        readonly method: Schema.String;
     }>]>;
 }>, import("effect/Cause").YieldableError>;
 /** Executor's app network refused a request before it reached the service. */

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

@@ -0,0 +1,102 @@
+/**
+ * Credential placement: where an auth method's secret fields may be sent. A placement is a
+ * location in the request, a header or a query parameter, and a value template built from
+ * literal text, references to the method's own account fields, and base64 of those. Executor's
+ * outbound network substitutes a placed credential handle only where a request matches one of
+ * its method's placements exactly, and refuses the request when the handle is anywhere else.
+ */
+import { Result, Schema } from "effect";
+/** A reference to one of the method's own account fields. */
+export declare const PlacementField: Schema.Struct<{
+    readonly field: Schema.NonEmptyString;
+}>;
+export type PlacementField = typeof PlacementField.Type;
+/** Literal text or a field reference: what base64 may encode. Base64 never nests. */
+export declare const PlacementText: Schema.Union<readonly [Schema.String, Schema.Struct<{
+    readonly field: Schema.NonEmptyString;
+}>]>;
+export type PlacementText = typeof PlacementText.Type;
+/** Base64 (RFC 4648, padded) of the UTF-8 bytes of its parts, such as Basic credentials. */
+export declare const PlacementBase64: Schema.Struct<{
+    readonly base64: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+        readonly field: Schema.NonEmptyString;
+    }>]>>;
+}>;
+export type PlacementBase64 = typeof PlacementBase64.Type;
+/** One part of a value template. Parts concatenate. */
+export declare const PlacementPart: Schema.Union<readonly [Schema.String, Schema.Struct<{
+    readonly field: Schema.NonEmptyString;
+}>, Schema.Struct<{
+    readonly base64: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+        readonly field: Schema.NonEmptyString;
+    }>]>>;
+}>]>;
+export type PlacementPart = typeof PlacementPart.Type;
+/** A lowercase HTTP header name (RFC 9110 token). */
+export declare const PlacementHeaderName: Schema.String;
+/**
+ * Where a credential may be sent and the exact value it is sent as. A header placement is the
+ * header's whole value; a query placement is the whole value of the named query parameter.
+ */
+export declare const Placement: Schema.Union<readonly [Schema.Struct<{
+    readonly in: Schema.Literal<"header">;
+    readonly name: Schema.String;
+    readonly value: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+        readonly field: Schema.NonEmptyString;
+    }>, Schema.Struct<{
+        readonly base64: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+            readonly field: Schema.NonEmptyString;
+        }>]>>;
+    }>]>>;
+}>, Schema.Struct<{
+    readonly in: Schema.Literal<"query">;
+    readonly name: Schema.NonEmptyString;
+    readonly value: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+        readonly field: Schema.NonEmptyString;
+    }>, Schema.Struct<{
+        readonly base64: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+            readonly field: Schema.NonEmptyString;
+        }>]>>;
+    }>]>>;
+}>]>;
+export type Placement = typeof Placement.Type;
+/** An auth method's placements. */
+export declare const Placements: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+    readonly in: Schema.Literal<"header">;
+    readonly name: Schema.String;
+    readonly value: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+        readonly field: Schema.NonEmptyString;
+    }>, Schema.Struct<{
+        readonly base64: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+            readonly field: Schema.NonEmptyString;
+        }>]>>;
+    }>]>>;
+}>, Schema.Struct<{
+    readonly in: Schema.Literal<"query">;
+    readonly name: Schema.NonEmptyString;
+    readonly value: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+        readonly field: Schema.NonEmptyString;
+    }>, Schema.Struct<{
+        readonly base64: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+            readonly field: Schema.NonEmptyString;
+        }>]>>;
+    }>]>>;
+}>]>>;
+/** Whether a part references a field. */
+export declare const isPlacementField: (part: PlacementPart) => part is PlacementField;
+/** The field names a template references, base64 parts included. */
+export declare const placementFields: (placement: Placement) => ReadonlySet<string>;
+/** Placements are equal when their JSON is: same location, name and template. */
+export declare const placementKey: (placement: Placement) => string;
+/** Placements in a stable order without repeats, so their order never changes an identity. */
+export declare const normalizePlacements: (placements: readonly Placement[]) => readonly Placement[];
+declare const PlacementFieldMissing_base: Schema.Class<PlacementFieldMissing, Schema.TaggedStruct<"PlacementFieldMissing", {
+    readonly field: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** A field the template references has no string value. */
+export declare class PlacementFieldMissing extends PlacementFieldMissing_base {
+    get message(): string;
+}
+/** Render a template with field values. A referenced field without a string value fails. */
+export declare const renderPlacement: (placement: Placement, fields: Readonly<Record<string, unknown>>) => Result.Result<string, PlacementFieldMissing>;
+export {};

package/types/apps/src/contracts/protocol-version.d.ts

@@ -3,4 +3,4 @@
  * snapshot. Its schemas are `protocols/current.ts`; released protocols are frozen. See notes/apps-publishing.md.
  * This file has no imports so the package build script can read it directly.
  */
-export declare const frameworkProtocol = 11;
+export declare const frameworkProtocol = 12;