effect-agent 0.1.0-beta.85 → 0.1.0-beta.87

package/dist/sandbox/PageCrawl.mjs

@@ -0,0 +1,124 @@
+import { t as __exportAll } from "../rolldown-runtime-D7D4PA-g.mjs";
+import { SandboxImplementation } from "./Sandbox.mjs";
+import { PageCaptureTargetUrl } from "./PageCapture.mjs";
+import { Context, Schema } from "effect";
+//#region src/sandbox/PageCrawl.ts
+var PageCrawl_exports = /* @__PURE__ */ __exportAll({
+	PageCrawl: () => PageCrawl,
+	PageCrawlError: () => PageCrawlError,
+	PageCrawlLimitError: () => PageCrawlLimitError,
+	PageCrawlLimits: () => PageCrawlLimits,
+	PageCrawlProtocolError: () => PageCrawlProtocolError,
+	PageCrawlPurpose: () => PageCrawlPurpose,
+	PageCrawlRateLimitedError: () => PageCrawlRateLimitedError,
+	PageCrawlRecord: () => PageCrawlRecord,
+	PageCrawlRecordMetadata: () => PageCrawlRecordMetadata,
+	PageCrawlRecordStatus: () => PageCrawlRecordStatus,
+	PageCrawlRequest: () => PageCrawlRequest,
+	PageCrawlStartUrl: () => PageCrawlStartUrl,
+	PageCrawlTerminalError: () => PageCrawlTerminalError
+});
+const MAX_PAGE_BYTES = 8388608;
+const MAX_TOTAL_BYTES = 67108864;
+const MAX_PAGES = 100;
+const MAX_DEPTH = 10;
+const MAX_DEADLINE_MILLIS = 6e5;
+const MAX_DIAGNOSTIC_LENGTH = 8e3;
+const PositiveInt = Schema.Int.check(Schema.isGreaterThan(0));
+const BoundedMarkdown = Schema.String.check(Schema.isMaxLength(MAX_PAGE_BYTES));
+const BoundedMessage = Schema.String.check(Schema.isMaxLength(MAX_DIAGNOSTIC_LENGTH));
+const HttpStatus = Schema.Int.check(Schema.isGreaterThanOrEqualTo(100), Schema.isLessThanOrEqualTo(599));
+/** One credential-free HTTPS URL. The first adapter confines every record to its exact host. */
+const PageCrawlStartUrl = PageCaptureTargetUrl;
+/** The declared uses Cloudflare evaluates against a site's Content Signals. */
+const PageCrawlPurpose = Schema.Literals([
+	"search",
+	"ai-input",
+	"ai-train"
+]);
+/** Immutable caller limits for one scoped crawl. */
+var PageCrawlLimits = class extends Schema.Class("PageCrawlLimits")({
+	maxPages: PositiveInt.check(Schema.isLessThanOrEqualTo(MAX_PAGES)),
+	maxDepth: PositiveInt.check(Schema.isLessThanOrEqualTo(MAX_DEPTH)),
+	maxPageBytes: PositiveInt.check(Schema.isLessThanOrEqualTo(MAX_PAGE_BYTES)),
+	maxTotalBytes: PositiveInt.check(Schema.isLessThanOrEqualTo(MAX_TOTAL_BYTES)),
+	deadlineMillis: PositiveInt.check(Schema.isLessThanOrEqualTo(MAX_DEADLINE_MILLIS))
+}) {};
+/** A rendered Markdown crawl rooted at one exact HTTPS host. */
+var PageCrawlRequest = class extends Schema.Class("PageCrawlRequest")({
+	startUrl: PageCrawlStartUrl,
+	purposes: Schema.Array(PageCrawlPurpose).check(Schema.isMinLength(1), Schema.isMaxLength(3), Schema.isUnique()),
+	limits: PageCrawlLimits
+}) {};
+/** Cloudflare's documented status for one discovered URL. */
+const PageCrawlRecordStatus = Schema.Literals([
+	"queued",
+	"completed",
+	"disallowed",
+	"skipped",
+	"errored",
+	"cancelled"
+]);
+/** Bounded origin metadata when Cloudflare reached the URL. */
+var PageCrawlRecordMetadata = class extends Schema.Class("PageCrawlRecordMetadata")({
+	status: HttpStatus,
+	url: PageCrawlStartUrl,
+	title: Schema.optionalKey(Schema.String.check(Schema.isMaxLength(4096)))
+}) {};
+/** One untrusted page record. Non-completed statuses may have no Markdown. */
+var PageCrawlRecord = class extends Schema.Class("PageCrawlRecord")({
+	url: PageCrawlStartUrl,
+	status: PageCrawlRecordStatus,
+	markdown: Schema.optionalKey(BoundedMarkdown),
+	metadata: Schema.optionalKey(PageCrawlRecordMetadata)
+}) {};
+/** Cloudflare refused a request because of a request-rate or browser-quota limit. */
+var PageCrawlRateLimitedError = class extends Schema.TaggedError()("PageCrawlRateLimitedError", {
+	implementation: SandboxImplementation,
+	reason: Schema.Literals(["rate", "quota"]),
+	retryAfterMillis: Schema.optionalKey(Schema.Natural),
+	message: BoundedMessage,
+	cause: Schema.optionalKey(Schema.Defect())
+}) {};
+/** The REST transport or provider response violated the crawl protocol. */
+var PageCrawlProtocolError = class extends Schema.TaggedError()("PageCrawlProtocolError", {
+	implementation: SandboxImplementation,
+	message: BoundedMessage,
+	cause: Schema.optionalKey(Schema.Defect())
+}) {};
+/** The first record or operation that crossed one immutable caller limit. */
+var PageCrawlLimitError = class extends Schema.TaggedError()("PageCrawlLimitError", {
+	implementation: SandboxImplementation,
+	limit: Schema.Literals([
+		"pages",
+		"page-bytes",
+		"total-bytes",
+		"deadline"
+	]),
+	maximum: PositiveInt,
+	observed: Schema.Natural,
+	message: BoundedMessage
+}) {};
+/** A documented non-success terminal job status. */
+var PageCrawlTerminalError = class extends Schema.TaggedError()("PageCrawlTerminalError", {
+	implementation: SandboxImplementation,
+	status: Schema.Literals([
+		"errored",
+		"cancelled_by_user",
+		"cancelled_due_to_timeout",
+		"cancelled_due_to_limits"
+	]),
+	message: BoundedMessage
+}) {};
+const PageCrawlError = Schema.Union([
+	PageCrawlRateLimitedError,
+	PageCrawlProtocolError,
+	PageCrawlLimitError,
+	PageCrawlTerminalError
+]);
+/** Scoped exact-host crawl stream. Provider job identity and polling stay adapter-private. */
+var PageCrawl = class extends Context.Service()("@effect-agent/sandbox/PageCrawl") {};
+//#endregion
+export { PageCrawl, PageCrawlError, PageCrawlLimitError, PageCrawlLimits, PageCrawlProtocolError, PageCrawlPurpose, PageCrawlRateLimitedError, PageCrawlRecord, PageCrawlRecordMetadata, PageCrawlRecordStatus, PageCrawlRequest, PageCrawlStartUrl, PageCrawlTerminalError, PageCrawl_exports as t };
+
+//# sourceMappingURL=PageCrawl.mjs.map

package/dist/sandbox/PageCrawl.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"PageCrawl.mjs","names":[],"sources":["../../src/sandbox/PageCrawl.ts"],"sourcesContent":["import { Context, Schema, type Scope, type Stream } from \"effect\";\n\nimport { PageCaptureTargetUrl } from \"./PageCapture.ts\";\nimport { SandboxImplementation } from \"./Sandbox.ts\";\n\nconst MAX_PAGE_BYTES = 8 * 1024 * 1024;\nconst MAX_TOTAL_BYTES = 64 * 1024 * 1024;\nconst MAX_PAGES = 100;\nconst MAX_DEPTH = 10;\nconst MAX_DEADLINE_MILLIS = 10 * 60_000;\nconst MAX_DIAGNOSTIC_LENGTH = 8_000;\nconst PositiveInt = Schema.Int.check(Schema.isGreaterThan(0));\nconst BoundedMarkdown = Schema.String.check(Schema.isMaxLength(MAX_PAGE_BYTES));\nconst BoundedMessage = Schema.String.check(Schema.isMaxLength(MAX_DIAGNOSTIC_LENGTH));\n\nconst HttpStatus = Schema.Int.check(\n  Schema.isGreaterThanOrEqualTo(100),\n  Schema.isLessThanOrEqualTo(599),\n);\n\n/** One credential-free HTTPS URL. The first adapter confines every record to its exact host. */\nexport const PageCrawlStartUrl = PageCaptureTargetUrl;\nexport type PageCrawlStartUrl = typeof PageCrawlStartUrl.Type;\n\n/** The declared uses Cloudflare evaluates against a site's Content Signals. */\nexport const PageCrawlPurpose = Schema.Literals([\"search\", \"ai-input\", \"ai-train\"]);\nexport type PageCrawlPurpose = typeof PageCrawlPurpose.Type;\n\n/** Immutable caller limits for one scoped crawl. */\nexport class PageCrawlLimits extends Schema.Class<PageCrawlLimits>(\"PageCrawlLimits\")({\n  maxPages: PositiveInt.check(Schema.isLessThanOrEqualTo(MAX_PAGES)),\n  maxDepth: PositiveInt.check(Schema.isLessThanOrEqualTo(MAX_DEPTH)),\n  maxPageBytes: PositiveInt.check(Schema.isLessThanOrEqualTo(MAX_PAGE_BYTES)),\n  maxTotalBytes: PositiveInt.check(Schema.isLessThanOrEqualTo(MAX_TOTAL_BYTES)),\n  deadlineMillis: PositiveInt.check(Schema.isLessThanOrEqualTo(MAX_DEADLINE_MILLIS)),\n}) {}\n\n/** A rendered Markdown crawl rooted at one exact HTTPS host. */\nexport class PageCrawlRequest extends Schema.Class<PageCrawlRequest>(\"PageCrawlRequest\")({\n  startUrl: PageCrawlStartUrl,\n  purposes: Schema.Array(PageCrawlPurpose).check(\n    Schema.isMinLength(1),\n    Schema.isMaxLength(3),\n    Schema.isUnique(),\n  ),\n  limits: PageCrawlLimits,\n}) {}\n\n/** Cloudflare's documented status for one discovered URL. */\nexport const PageCrawlRecordStatus = Schema.Literals([\n  \"queued\",\n  \"completed\",\n  \"disallowed\",\n  \"skipped\",\n  \"errored\",\n  \"cancelled\",\n]);\n\nexport type PageCrawlRecordStatus = typeof PageCrawlRecordStatus.Type;\n\n/** Bounded origin metadata when Cloudflare reached the URL. */\nexport class PageCrawlRecordMetadata extends Schema.Class<PageCrawlRecordMetadata>(\n  \"PageCrawlRecordMetadata\",\n)({\n  status: HttpStatus,\n  url: PageCrawlStartUrl,\n  title: Schema.optionalKey(Schema.String.check(Schema.isMaxLength(4_096))),\n}) {}\n\n/** One untrusted page record. Non-completed statuses may have no Markdown. */\nexport class PageCrawlRecord extends Schema.Class<PageCrawlRecord>(\"PageCrawlRecord\")({\n  url: PageCrawlStartUrl,\n  status: PageCrawlRecordStatus,\n  markdown: Schema.optionalKey(BoundedMarkdown),\n  metadata: Schema.optionalKey(PageCrawlRecordMetadata),\n}) {}\n\n/** Cloudflare refused a request because of a request-rate or browser-quota limit. */\nexport class PageCrawlRateLimitedError extends Schema.TaggedError<PageCrawlRateLimitedError>()(\n  \"PageCrawlRateLimitedError\",\n  {\n    implementation: SandboxImplementation,\n    reason: Schema.Literals([\"rate\", \"quota\"]),\n    retryAfterMillis: Schema.optionalKey(Schema.Natural),\n    message: BoundedMessage,\n    cause: Schema.optionalKey(Schema.Defect()),\n  },\n) {}\n\n/** The REST transport or provider response violated the crawl protocol. */\nexport class PageCrawlProtocolError extends Schema.TaggedError<PageCrawlProtocolError>()(\n  \"PageCrawlProtocolError\",\n  {\n    implementation: SandboxImplementation,\n    message: BoundedMessage,\n    cause: Schema.optionalKey(Schema.Defect()),\n  },\n) {}\n\n/** The first record or operation that crossed one immutable caller limit. */\nexport class PageCrawlLimitError extends Schema.TaggedError<PageCrawlLimitError>()(\n  \"PageCrawlLimitError\",\n  {\n    implementation: SandboxImplementation,\n    limit: Schema.Literals([\"pages\", \"page-bytes\", \"total-bytes\", \"deadline\"]),\n    maximum: PositiveInt,\n    observed: Schema.Natural,\n    message: BoundedMessage,\n  },\n) {}\n\n/** A documented non-success terminal job status. */\nexport class PageCrawlTerminalError extends Schema.TaggedError<PageCrawlTerminalError>()(\n  \"PageCrawlTerminalError\",\n  {\n    implementation: SandboxImplementation,\n    status: Schema.Literals([\n      \"errored\",\n      \"cancelled_by_user\",\n      \"cancelled_due_to_timeout\",\n      \"cancelled_due_to_limits\",\n    ]),\n    message: BoundedMessage,\n  },\n) {}\n\nexport const PageCrawlError = Schema.Union([\n  PageCrawlRateLimitedError,\n  PageCrawlProtocolError,\n  PageCrawlLimitError,\n  PageCrawlTerminalError,\n]);\n\nexport type PageCrawlError = typeof PageCrawlError.Type;\n\n/** Scoped exact-host crawl stream. Provider job identity and polling stay adapter-private. */\nexport class PageCrawl extends Context.Service<\n  PageCrawl,\n  {\n    readonly crawl: (\n      request: PageCrawlRequest,\n    ) => Stream.Stream<PageCrawlRecord, PageCrawlError, Scope.Scope>;\n  }\n>()(\"@effect-agent/sandbox/PageCrawl\") {}\n\nexport type PageCrawlCrawl = (\n  request: PageCrawlRequest,\n) => Stream.Stream<PageCrawlRecord, PageCrawlError, Scope.Scope>;\n"],"mappings":"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"}

package/dist/sandbox/PageScreenshot.d.mts

@@ -0,0 +1,2 @@
+import { a as PageScreenshotOutputLimitError, i as PageScreenshotLimits, n as PageScreenshotCapture, o as PageScreenshotRequest, r as PageScreenshotError, s as PageScreenshotResult, t as PageScreenshot } from "../PageScreenshot-BpgZKAxl.mjs";
+export { PageScreenshot, PageScreenshotCapture, PageScreenshotError, PageScreenshotLimits, PageScreenshotOutputLimitError, PageScreenshotRequest, PageScreenshotResult };

package/dist/sandbox/PageScreenshot.mjs

@@ -0,0 +1,53 @@
+import { t as __exportAll } from "../rolldown-runtime-D7D4PA-g.mjs";
+import { SandboxImplementation } from "./Sandbox.mjs";
+import { PageCaptureEngine, PageCaptureNavigationError, PageCaptureProtocolError, PageCaptureRateLimitedError, PageCaptureTarget, PageCaptureUnsupportedError, PageNavigationOptions, PageResourcePolicy, PageViewport } from "./PageCapture.mjs";
+import { Context, Schema } from "effect";
+//#region src/sandbox/PageScreenshot.ts
+var PageScreenshot_exports = /* @__PURE__ */ __exportAll({
+	PageScreenshot: () => PageScreenshot,
+	PageScreenshotError: () => PageScreenshotError,
+	PageScreenshotLimits: () => PageScreenshotLimits,
+	PageScreenshotOutputLimitError: () => PageScreenshotOutputLimitError,
+	PageScreenshotRequest: () => PageScreenshotRequest,
+	PageScreenshotResult: () => PageScreenshotResult
+});
+const MAX_SCREENSHOT_BYTES = 8388608;
+const PositiveInt = Schema.Int.check(Schema.isGreaterThan(0));
+/** The byte limit and full-page choice are fixed before Browser Run starts. */
+var PageScreenshotLimits = class extends Schema.Class("PageScreenshotLimits")({ maxOutputBytes: PositiveInt.check(Schema.isLessThanOrEqualTo(MAX_SCREENSHOT_BYTES)) }) {};
+/** Schema-first request for exactly one PNG screenshot. */
+var PageScreenshotRequest = class extends Schema.Class("PageScreenshotRequest")({
+	target: PageCaptureTarget,
+	engine: PageCaptureEngine,
+	limits: PageScreenshotLimits,
+	fullPage: Schema.Boolean,
+	navigation: Schema.optionalKey(PageNavigationOptions),
+	viewport: Schema.optionalKey(PageViewport),
+	resourcePolicy: Schema.optionalKey(PageResourcePolicy)
+}) {};
+/** The only successful output: bytes are caller-owned and never durable framework data. */
+var PageScreenshotResult = class extends Schema.Class("PageScreenshotResult")({
+	implementation: SandboxImplementation,
+	mediaType: Schema.Literal("image/png"),
+	bytes: Schema.Uint8Array.check(Schema.isMaxLength(MAX_SCREENSHOT_BYTES))
+}) {};
+/** The response crossed the request's PNG byte limit. */
+var PageScreenshotOutputLimitError = class extends Schema.TaggedError()("PageScreenshotOutputLimitError", {
+	implementation: SandboxImplementation,
+	limit: PositiveInt,
+	observed: Schema.Natural
+}) {};
+/** Expected screenshot failures. The shared capture errors keep identical semantics. */
+const PageScreenshotError = Schema.Union([
+	PageCaptureRateLimitedError,
+	PageCaptureNavigationError,
+	PageCaptureUnsupportedError,
+	PageCaptureProtocolError,
+	PageScreenshotOutputLimitError
+]);
+/** Stateless, one-output PNG capture port. It owns neither persistence nor later byte handoff. */
+var PageScreenshot = class extends Context.Service()("@effect-agent/sandbox/PageScreenshot") {};
+//#endregion
+export { PageScreenshot, PageScreenshotError, PageScreenshotLimits, PageScreenshotOutputLimitError, PageScreenshotRequest, PageScreenshotResult, PageScreenshot_exports as t };
+
+//# sourceMappingURL=PageScreenshot.mjs.map

package/dist/sandbox/PageScreenshot.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"PageScreenshot.mjs","names":[],"sources":["../../src/sandbox/PageScreenshot.ts"],"sourcesContent":["import { Context, Schema, type Effect } from \"effect\";\n\nimport {\n  PageCaptureEngine,\n  PageCaptureNavigationError,\n  PageCaptureProtocolError,\n  PageCaptureRateLimitedError,\n  PageCaptureTarget,\n  PageCaptureUnsupportedError,\n  PageNavigationOptions,\n  PageResourcePolicy,\n  PageViewport,\n} from \"./PageCapture.ts\";\nimport { SandboxImplementation } from \"./Sandbox.ts\";\n\nconst MAX_SCREENSHOT_BYTES = 8 * 1024 * 1024;\nconst PositiveInt = Schema.Int.check(Schema.isGreaterThan(0));\n\n/** The byte limit and full-page choice are fixed before Browser Run starts. */\nexport class PageScreenshotLimits extends Schema.Class<PageScreenshotLimits>(\n  \"PageScreenshotLimits\",\n)({\n  maxOutputBytes: PositiveInt.check(Schema.isLessThanOrEqualTo(MAX_SCREENSHOT_BYTES)),\n}) {}\n\n/** Schema-first request for exactly one PNG screenshot. */\nexport class PageScreenshotRequest extends Schema.Class<PageScreenshotRequest>(\n  \"PageScreenshotRequest\",\n)({\n  target: PageCaptureTarget,\n  engine: PageCaptureEngine,\n  limits: PageScreenshotLimits,\n  fullPage: Schema.Boolean,\n  navigation: Schema.optionalKey(PageNavigationOptions),\n  viewport: Schema.optionalKey(PageViewport),\n  resourcePolicy: Schema.optionalKey(PageResourcePolicy),\n}) {}\n\n/** The only successful output: bytes are caller-owned and never durable framework data. */\nexport class PageScreenshotResult extends Schema.Class<PageScreenshotResult>(\n  \"PageScreenshotResult\",\n)({\n  implementation: SandboxImplementation,\n  mediaType: Schema.Literal(\"image/png\"),\n  bytes: Schema.Uint8Array.check(Schema.isMaxLength(MAX_SCREENSHOT_BYTES)),\n}) {}\n\n/** The response crossed the request's PNG byte limit. */\nexport class PageScreenshotOutputLimitError extends Schema.TaggedError<PageScreenshotOutputLimitError>()(\n  \"PageScreenshotOutputLimitError\",\n  {\n    implementation: SandboxImplementation,\n    limit: PositiveInt,\n    observed: Schema.Natural,\n  },\n) {}\n\n/** Expected screenshot failures. The shared capture errors keep identical semantics. */\nexport const PageScreenshotError = Schema.Union([\n  PageCaptureRateLimitedError,\n  PageCaptureNavigationError,\n  PageCaptureUnsupportedError,\n  PageCaptureProtocolError,\n  PageScreenshotOutputLimitError,\n]);\n\nexport type PageScreenshotError = typeof PageScreenshotError.Type;\n\n/** Stateless, one-output PNG capture port. It owns neither persistence nor later byte handoff. */\nexport class PageScreenshot extends Context.Service<\n  PageScreenshot,\n  {\n    readonly capture: (\n      request: PageScreenshotRequest,\n    ) => Effect.Effect<PageScreenshotResult, PageScreenshotError>;\n  }\n>()(\"@effect-agent/sandbox/PageScreenshot\") {}\n\nexport type PageScreenshotCapture = (\n  request: PageScreenshotRequest,\n) => Effect.Effect<PageScreenshotResult, PageScreenshotError>;\n"],"mappings":";;;;;;;;;;;;;AAeA,MAAM,uBAAuB;AAC7B,MAAM,cAAc,OAAO,IAAI,MAAM,OAAO,cAAc,CAAC,CAAC;;AAG5D,IAAa,uBAAb,cAA0C,OAAO,MAC/C,sBACF,CAAC,CAAC,EACA,gBAAgB,YAAY,MAAM,OAAO,oBAAoB,oBAAoB,CAAC,EACpF,CAAC,CAAC,CAAC,CAAC;;AAGJ,IAAa,wBAAb,cAA2C,OAAO,MAChD,uBACF,CAAC,CAAC;CACA,QAAQ;CACR,QAAQ;CACR,QAAQ;CACR,UAAU,OAAO;CACjB,YAAY,OAAO,YAAY,qBAAqB;CACpD,UAAU,OAAO,YAAY,YAAY;CACzC,gBAAgB,OAAO,YAAY,kBAAkB;AACvD,CAAC,CAAC,CAAC,CAAC;;AAGJ,IAAa,uBAAb,cAA0C,OAAO,MAC/C,sBACF,CAAC,CAAC;CACA,gBAAgB;CAChB,WAAW,OAAO,QAAQ,WAAW;CACrC,OAAO,OAAO,WAAW,MAAM,OAAO,YAAY,oBAAoB,CAAC;AACzE,CAAC,CAAC,CAAC,CAAC;;AAGJ,IAAa,iCAAb,cAAoD,OAAO,YAA4C,CAAC,CACtG,kCACA;CACE,gBAAgB;CAChB,OAAO;CACP,UAAU,OAAO;AACnB,CACF,CAAC,CAAC,CAAC;;AAGH,MAAa,sBAAsB,OAAO,MAAM;CAC9C;CACA;CACA;CACA;CACA;AACF,CAAC;;AAKD,IAAa,iBAAb,cAAoC,QAAQ,QAO1C,CAAC,CAAC,sCAAsC,CAAC,CAAC,CAAC"}

package/dist/sandbox/ProtectedBrowser.d.mts

@@ -0,0 +1,252 @@
+import { InteractiveBrowserPolicy } from "./InteractiveBrowser.mjs";
+import { Context, Effect, Layer, Redacted, Schema, Scope } from "effect";
+declare namespace ProtectedBrowser_d_exports {
+  export { BrowserCredentialAccess, BrowserCredentialMaterial, BrowserReference, CardCredential, CredentialAccessError, CredentialAccessRequest, CredentialDispatch, CredentialFieldRole, CredentialKind, CredentialMilestone, CredentialObservationDecision, CredentialObservationGrant, CredentialOffer, CredentialOfferMetadata, CredentialOrigin, CredentialTarget, CredentialUseAuthorization, CredentialUseResult, ListCredentialOffers, LoginCredential, ProtectedBrowser, ProtectedBrowserAction, ProtectedBrowserClick, ProtectedBrowserControl, ProtectedBrowserError, ProtectedBrowserFill, ProtectedBrowserHandle, ProtectedBrowserNavigate, ProtectedBrowserObservation, ProtectedBrowserSession, ProtectedCleanup, ProtectedObservationState, UseCredential };
+}
+/** Canonical HTTPS origin, including a non-default port. Host grants match exactly. */
+declare const CredentialOrigin: Schema.String;
+declare const BrowserReference: Schema.String;
+declare const CredentialKind: Schema.Literals<readonly ["login", "card"]>;
+declare const CredentialFieldRole: Schema.Literals<readonly ["username", "password", "card-name", "card-number", "card-expiry", "card-expiry-month", "card-expiry-year", "card-security-code"]>;
+declare const CredentialTarget_base: Schema.Class<CredentialTarget, Schema.Struct<{
+  readonly topOrigin: Schema.String;
+  readonly frameOrigin: Schema.String;
+  readonly recipientOrigin: Schema.String;
+  readonly document: Schema.String;
+  readonly frame: Schema.String;
+  readonly form: Schema.String;
+}>, {}>;
+declare class CredentialTarget extends CredentialTarget_base {}
+declare const ProtectedBrowserControl_base: Schema.Class<ProtectedBrowserControl, Schema.Struct<{
+  readonly ref: Schema.String;
+  readonly target: typeof CredentialTarget;
+  readonly role: Schema.Union<readonly [Schema.Literals<readonly ["username", "password", "card-name", "card-number", "card-expiry", "card-expiry-month", "card-expiry-year", "card-security-code"]>, Schema.Literals<readonly ["text", "select", "radio", "checkbox", "submit", "link", "button", "unsupported"]>]>;
+  readonly label: Schema.String;
+  /** Current native radio/checkbox state; field values are never included. */
+  readonly checked: Schema.optionalKey<Schema.Boolean>;
+  /** Resolved HTTPS destination for a native link; target.recipientOrigin is its origin. */
+  readonly url: Schema.optionalKey<Schema.NonEmptyString>;
+}>, {}>;
+declare class ProtectedBrowserControl extends ProtectedBrowserControl_base {}
+declare const ProtectedBrowserObservation_base: Schema.Class<ProtectedBrowserObservation, Schema.Struct<{
+  readonly document: Schema.String;
+  readonly topOrigin: Schema.String;
+  readonly text: Schema.String;
+  readonly controls: Schema.$Array<typeof ProtectedBrowserControl>;
+  readonly truncated: Schema.Boolean;
+  readonly observation: Schema.Literals<readonly ["before-exposure", "approved-after-exposure"]>;
+}>, {}>;
+declare class ProtectedBrowserObservation extends ProtectedBrowserObservation_base {}
+declare const CredentialOfferMetadata_base: Schema.Class<CredentialOfferMetadata, Schema.Struct<{
+  readonly label: Schema.String;
+  readonly brand: Schema.optionalKey<Schema.String>;
+  readonly lastFour: Schema.optionalKey<Schema.String>;
+  /** Plaintext metadata disclosed only when the host authorizes listing this offer. */
+  readonly billingAddress: Schema.optionalKey<Schema.Struct<{
+    readonly name: Schema.optionalKey<Schema.String>;
+    readonly line1: Schema.optionalKey<Schema.String>;
+    readonly line2: Schema.optionalKey<Schema.String>;
+    readonly city: Schema.optionalKey<Schema.String>;
+    readonly region: Schema.optionalKey<Schema.String>;
+    readonly postalCode: Schema.optionalKey<Schema.String>;
+    readonly country: Schema.optionalKey<Schema.String>;
+  }>>;
+}>, {}>;
+declare class CredentialOfferMetadata extends CredentialOfferMetadata_base {}
+declare const CredentialOffer_base: Schema.Class<CredentialOffer, Schema.Struct<{
+  readonly ref: Schema.String;
+  readonly kind: Schema.Literals<readonly ["login", "card"]>;
+  readonly metadata: typeof CredentialOfferMetadata;
+}>, {}>;
+declare class CredentialOffer extends CredentialOffer_base {}
+declare const ListCredentialOffers_base: Schema.Class<ListCredentialOffers, Schema.Struct<{
+  readonly kind: Schema.Literals<readonly ["login", "card"]>;
+  readonly target: Schema.String;
+}>, {}>;
+declare class ListCredentialOffers extends ListCredentialOffers_base {}
+declare const UseCredential_base: Schema.Class<UseCredential, Schema.Struct<{
+  readonly offer: Schema.String;
+  readonly fields: Schema.$Array<Schema.Struct<{
+    readonly ref: Schema.String;
+    readonly role: Schema.Literals<readonly ["username", "password", "card-name", "card-number", "card-expiry", "card-expiry-month", "card-expiry-year", "card-security-code"]>;
+  }>>;
+  readonly submit: Schema.optionalKey<Schema.String>;
+}>, {}>;
+declare class UseCredential extends UseCredential_base {}
+declare const ProtectedBrowserNavigate_base: Schema.Class<ProtectedBrowserNavigate, Schema.Struct<{
+  readonly url: Schema.String;
+}>, {}>;
+declare class ProtectedBrowserNavigate extends ProtectedBrowserNavigate_base {}
+declare const ProtectedBrowserClick_base: Schema.Class<ProtectedBrowserClick, Schema.Struct<{
+  readonly ref: Schema.String;
+}>, {}>;
+declare class ProtectedBrowserClick extends ProtectedBrowserClick_base {}
+declare const ProtectedBrowserFill_base: Schema.Class<ProtectedBrowserFill, Schema.Struct<{
+  readonly ref: Schema.String;
+  readonly value: Schema.String;
+}>, {}>;
+/**
+ * Non-secret text for an ordinary text control or native single select in the current observation.
+ * Never pass credential material. Credential roles, including username, require useCredential.
+ * Selects match a unique enabled option value, then a unique exact trimmed label. Empty text clears.
+ */
+declare class ProtectedBrowserFill extends ProtectedBrowserFill_base {}
+declare const CredentialDispatch: Schema.Literals<readonly ["not-dispatched", "possibly-dispatched", "dispatched"]>;
+declare const CredentialMilestone: Schema.Literals<readonly ["none", "partial-fill", "filled", "submission-dispatched"]>;
+declare const ProtectedObservationState: Schema.Literals<readonly ["before-exposure", "protected", "approved-after-exposure", "closed"]>;
+declare const ProtectedCleanup: Schema.Literals<readonly ["not-requested", "confirmed", "unconfirmed"]>;
+declare const ProtectedBrowserError_base: Schema.Class<ProtectedBrowserError, Schema.TaggedStruct<"ProtectedBrowserError", {
+  readonly dispatch: Schema.Literals<readonly ["not-dispatched", "possibly-dispatched", "dispatched"]>;
+  readonly milestone: Schema.Literals<readonly ["none", "partial-fill", "filled", "submission-dispatched"]>;
+  readonly observation: Schema.Literals<readonly ["before-exposure", "protected", "approved-after-exposure", "closed"]>;
+  readonly cleanup: Schema.Literals<readonly ["not-requested", "confirmed", "unconfirmed"]>;
+  readonly reason: Schema.Literals<readonly ["denied", "missing-credential", "stale-reference", "unsupported", "needs-attention", "busy", "closed", "limit", "timeout", "provider", "resolver", "outcome-unknown", "observation-blocked"]>;
+}>, import("effect/Cause").YieldableError>;
+/** No foreign message/cause or page data may enter this failure. Closure does not undo dispatch. */
+declare class ProtectedBrowserError extends ProtectedBrowserError_base {}
+declare const CredentialUseResult_base: Schema.Class<CredentialUseResult, Schema.Struct<{
+  readonly dispatch: Schema.Literals<readonly ["not-dispatched", "possibly-dispatched", "dispatched"]>;
+  readonly milestone: Schema.Literals<readonly ["none", "partial-fill", "filled", "submission-dispatched"]>;
+  readonly observation: Schema.Literals<readonly ["before-exposure", "protected", "approved-after-exposure", "closed"]>;
+  readonly cleanup: Schema.Literals<readonly ["not-requested", "confirmed", "unconfirmed"]>;
+  readonly authentication: Schema.Literal<"unverified">;
+}>, {}>;
+declare class CredentialUseResult extends CredentialUseResult_base {}
+/** Host-only material. Never encode it into Tool results, checkpoints, or storage. */
+declare const LoginCredential: Schema.TaggedStruct<"LoginCredential", {
+  readonly username: Schema.Redacted<Schema.NonEmptyString>;
+  readonly password: Schema.Redacted<Schema.NonEmptyString>;
+}>;
+/** Security codes are transient, never persisted. Dummy tests are not PCI compliance evidence. */
+declare const CardCredential: Schema.TaggedStruct<"CardCredential", {
+  readonly name: Schema.Redacted<Schema.NonEmptyString>;
+  readonly number: Schema.Redacted<Schema.String>;
+  readonly expiry: Schema.Redacted<Schema.NonEmptyString>;
+  readonly expiryMonth: Schema.Redacted<Schema.String>;
+  readonly expiryYear: Schema.Redacted<Schema.String>;
+  readonly securityCode: Schema.optionalKey<Schema.Redacted<Schema.String>>;
+}>;
+declare const BrowserCredentialMaterial: Schema.Union<readonly [Schema.TaggedStruct<"LoginCredential", {
+  readonly username: Schema.Redacted<Schema.NonEmptyString>;
+  readonly password: Schema.Redacted<Schema.NonEmptyString>;
+}>, Schema.TaggedStruct<"CardCredential", {
+  readonly name: Schema.Redacted<Schema.NonEmptyString>;
+  readonly number: Schema.Redacted<Schema.String>;
+  readonly expiry: Schema.Redacted<Schema.NonEmptyString>;
+  readonly expiryMonth: Schema.Redacted<Schema.String>;
+  readonly expiryYear: Schema.Redacted<Schema.String>;
+  readonly securityCode: Schema.optionalKey<Schema.Redacted<Schema.String>>;
+}>]>;
+type BrowserCredentialMaterial = typeof BrowserCredentialMaterial.Type;
+declare const CredentialAccessError_base: Schema.Class<CredentialAccessError, Schema.TaggedStruct<"CredentialAccessError", {
+  readonly reason: Schema.Literals<readonly ["denied", "missing-credential", "needs-attention", "resolver"]>;
+}>, import("effect/Cause").YieldableError>;
+declare class CredentialAccessError extends CredentialAccessError_base {}
+interface CredentialAccessRequest {
+  readonly caller: Redacted.Redacted<string>;
+  readonly kind: typeof CredentialKind.Type;
+  readonly target: CredentialTarget;
+}
+interface CredentialUseAuthorization extends CredentialAccessRequest {
+  readonly key: Redacted.Redacted<string>;
+  readonly roles: ReadonlyArray<typeof CredentialFieldRole.Type>;
+  readonly submit: boolean;
+}
+/** Exact current action proposed to host authority; no ordinary fill value or secret is included. */
+declare const ProtectedBrowserAction: Schema.Union<readonly [Schema.TaggedStruct<"Navigate", {
+  readonly url: Schema.String;
+}>, Schema.TaggedStruct<"Fill", {
+  readonly ref: Schema.String;
+  readonly target: typeof CredentialTarget;
+  readonly role: Schema.Literals<readonly ["text", "select"]>;
+}>, Schema.TaggedStruct<"Click", {
+  readonly ref: Schema.String;
+  readonly target: typeof CredentialTarget;
+  readonly role: Schema.Literals<readonly ["button", "radio", "checkbox"]>;
+}>, Schema.TaggedStruct<"Click", {
+  readonly ref: Schema.String;
+  readonly target: typeof CredentialTarget;
+  readonly role: Schema.Literal<"link">;
+  readonly url: Schema.NonEmptyString;
+}>, Schema.TaggedStruct<"Submit", {
+  readonly ref: Schema.String;
+  readonly target: typeof CredentialTarget;
+}>]>;
+type ProtectedBrowserAction = typeof ProtectedBrowserAction.Type;
+declare const CredentialObservationGrant_base: Schema.Class<CredentialObservationGrant, Schema.Struct<{
+  readonly decision: Schema.Literal<"trust-recipient-no-credential-echo">;
+  readonly origins: Schema.$Array<Schema.String>;
+}>, {}>;
+/**
+ * Trust only these current observation origins. The top origin must be included. Other frames
+ * supply neither text nor usable refs. This does not expand network policy or credential grants.
+ */
+declare class CredentialObservationGrant extends CredentialObservationGrant_base {}
+declare const CredentialObservationDecision: Schema.Union<readonly [Schema.Literals<readonly ["trust-recipient-no-credential-echo", "deny"]>, typeof CredentialObservationGrant]>;
+declare const BrowserCredentialAccess_base: Context.ServiceClass<BrowserCredentialAccess, "@effect-agent/sandbox/BrowserCredentialAccess", {
+  readonly caller: Effect.Effect<Redacted.Redacted<string>, CredentialAccessError>;
+  readonly list: (request: CredentialAccessRequest) => Effect.Effect<ReadonlyArray<{
+    readonly key: Redacted.Redacted<string>;
+    readonly metadata: CredentialOfferMetadata;
+  }>, CredentialAccessError>;
+  readonly authorize: (request: CredentialUseAuthorization) => Effect.Effect<void, CredentialAccessError>;
+  readonly resolve: (request: CredentialUseAuthorization) => Effect.Effect<BrowserCredentialMaterial, CredentialAccessError>;
+  /**
+   * Optional host authority for every ordinary navigate/fill/click, mandatory for Submit.
+   * Recheck caller ownership, user intent, current submission/continuation grants for ALL prior
+   * exposures, and this exact target. Exposures may come from separate credential frames/forms.
+   * Without this hook, ordinary actions retain their observation gate and Submit is unsupported.
+   * Observation trust alone never authorizes a new native submit. Called again on each action;
+   * approvals are not cached. The pass revalidates caller and target after this hook returns.
+   */
+  readonly authorizeAction?: (request: {
+    readonly caller: Redacted.Redacted<string>;
+    readonly action: ProtectedBrowserAction;
+    readonly exposures: ReadonlyArray<CredentialTarget>;
+  }) => Effect.Effect<void, CredentialAccessError>;
+  /**
+   * Explicitly trust all observed destinations not to echo credentials, including transformed
+   * or delayed echoes. Called for every observation and non-secret action after exposure.
+   * The string grant trusts all current observed origins. Return CredentialObservationGrant
+   * to select an explicit subset instead. This is recipient trust, not submission authority,
+   * a universal secrecy guarantee, or a login verifier.
+   */
+  readonly observation: (request: {
+    readonly caller: Redacted.Redacted<string>;
+    readonly topOrigin: typeof CredentialOrigin.Type;
+    readonly frameOrigins: ReadonlyArray<typeof CredentialOrigin.Type>;
+    readonly exposures: ReadonlyArray<CredentialTarget>;
+  }) => Effect.Effect<typeof CredentialObservationDecision.Type, CredentialAccessError>;
+}>;
+/**
+ * Host-only vault and grant port. Derive caller from the authorized invocation, never Tool input.
+ * Recheck account ownership, current grants, merchant/frame/recipient pairing, and any side
+ * effects caused by filling. Listing authorizes metadata only. Grant checks never widen network
+ * policy. Implementations must not log material or put it in defects/traces.
+ */
+declare class BrowserCredentialAccess extends BrowserCredentialAccess_base {}
+/** A private ephemeral pass. No selectors, JavaScript, screenshots, viewer, or provider identity. */
+interface ProtectedBrowserHandle {
+  readonly navigate: (request: ProtectedBrowserNavigate) => Effect.Effect<void, ProtectedBrowserError>;
+  readonly observe: Effect.Effect<ProtectedBrowserObservation, ProtectedBrowserError>;
+  readonly click: (request: ProtectedBrowserClick) => Effect.Effect<void, ProtectedBrowserError>;
+  /** Uses the same lock, budgets, current-target checks and post-exposure grant as other actions. */
+  readonly fill: (request: ProtectedBrowserFill) => Effect.Effect<void, ProtectedBrowserError>;
+  readonly listCredentialOffers: (request: ListCredentialOffers) => Effect.Effect<ReadonlyArray<CredentialOffer>, ProtectedBrowserError>;
+  readonly useCredential: (request: UseCredential) => Effect.Effect<CredentialUseResult, ProtectedBrowserError>;
+  readonly close: Effect.Effect<typeof ProtectedCleanup.Type>;
+}
+declare const ProtectedBrowser_base: Context.ServiceClass<ProtectedBrowser, "@effect-agent/sandbox/ProtectedBrowser", {
+  readonly open: (policy: InteractiveBrowserPolicy) => Effect.Effect<ProtectedBrowserHandle, ProtectedBrowserError, Scope.Scope | BrowserCredentialAccess>;
+}>;
+declare class ProtectedBrowser extends ProtectedBrowser_base {}
+declare const ProtectedBrowserSession_base: Context.ServiceClass<ProtectedBrowserSession, "@effect-agent/sandbox/ProtectedBrowserSession", {
+  readonly get: Effect.Effect<ProtectedBrowserHandle, ProtectedBrowserError>;
+}>;
+/** Build once in an execution/Attempt Layer. Acquires lazily and shares one pass across Tools. */
+declare class ProtectedBrowserSession extends ProtectedBrowserSession_base {
+  static layer(policy: InteractiveBrowserPolicy): Layer.Layer<ProtectedBrowserSession, never, BrowserCredentialAccess | ProtectedBrowser>;
+}
+//#endregion
+export { BrowserCredentialAccess, BrowserCredentialMaterial, BrowserReference, CardCredential, CredentialAccessError, CredentialAccessRequest, CredentialDispatch, CredentialFieldRole, CredentialKind, CredentialMilestone, CredentialObservationDecision, CredentialObservationGrant, CredentialOffer, CredentialOfferMetadata, CredentialOrigin, CredentialTarget, CredentialUseAuthorization, CredentialUseResult, ListCredentialOffers, LoginCredential, ProtectedBrowser, ProtectedBrowserAction, ProtectedBrowserClick, ProtectedBrowserControl, ProtectedBrowserError, ProtectedBrowserFill, ProtectedBrowserHandle, ProtectedBrowserNavigate, ProtectedBrowserObservation, ProtectedBrowserSession, ProtectedCleanup, ProtectedObservationState, UseCredential, ProtectedBrowser_d_exports as t };
+//# sourceMappingURL=ProtectedBrowser.d.mts.map