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

package/dist/PageCapture-Df8Xwskw.d.mts

@@ -0,0 +1,583 @@
+import { p as SandboxImplementation } from "./Sandbox-CEsDWBLq.mjs";
+import { Context, Effect, Schema } from "effect";
+declare namespace PageCapture_d_exports {
+  export { CapturePageContent, CapturePageLinks, CapturePageMarkdown, CapturePageScrape, CapturePageStructured, PageCapture, PageCaptureAction, PageCaptureCapture, PageCaptureEngine, PageCaptureError, PageCaptureInferencePolicyError, PageCaptureInferenceUse, PageCaptureLimits, PageCaptureLinkUrl, PageCaptureNavigationError, PageCaptureOutput, PageCaptureOutputLimitError, PageCaptureProtocolError, PageCaptureRateLimitedError, PageCaptureRequest, PageCaptureResourceUse, PageCaptureResponseFormat, PageCaptureResult, PageCaptureTarget, PageCaptureTargetUrl, PageCaptureUnsupportedError, PageContentCaptured, PageHtmlTarget, PageLinksCaptured, PageMarkdownCaptured, PageNavigationOptions, PageResourcePolicy, PageScrapeAttribute, PageScrapeCaptured, PageScrapeElement, PageScrapeGroup, PageSelectorWait, PageStructuredCaptured, PageUrlTarget, PageViewport };
+}
+/** Absolute, bounded HTTPS navigation URL that never carries embedded credentials. */
+declare const PageCaptureTargetUrl: Schema.NonEmptyString;
+type PageCaptureTargetUrl = typeof PageCaptureTargetUrl.Type;
+/** Discovered HTTP(S) links are data, never navigation authority, and carry no credentials. */
+declare const PageCaptureLinkUrl: Schema.NonEmptyString;
+type PageCaptureLinkUrl = typeof PageCaptureLinkUrl.Type;
+declare const ResponseFormatPrimitive: Schema.Literals<readonly ["string", "number", "boolean", "array", "object", "null", "integer"]>;
+declare const ResponseFormatPrimitiveList: Schema.$Array<Schema.Literals<readonly ["string", "number", "boolean", "array", "object", "null", "integer"]>>;
+type ResponseFormatNode = Schema.JsonObject & {
+  readonly $schema?: string | undefined;
+  readonly $id?: string | undefined;
+  readonly $ref?: string | undefined;
+  readonly $anchor?: string | undefined;
+  readonly $dynamicRef?: string | undefined;
+  readonly $dynamicAnchor?: string | undefined;
+  readonly $comment?: string | undefined;
+  readonly title?: string | undefined;
+  readonly description?: string | undefined;
+  readonly default?: Schema.Json | undefined;
+  readonly deprecated?: boolean | undefined;
+  readonly readOnly?: boolean | undefined;
+  readonly writeOnly?: boolean | undefined;
+  readonly examples?: ReadonlyArray<Schema.Json> | undefined;
+  readonly type?: typeof ResponseFormatPrimitive.Type | typeof ResponseFormatPrimitiveList.Type | undefined;
+  readonly enum?: ReadonlyArray<Schema.Json> | undefined;
+  readonly const?: Schema.Json | undefined;
+  readonly multipleOf?: number | undefined;
+  readonly maximum?: number | undefined;
+  readonly exclusiveMaximum?: number | undefined;
+  readonly minimum?: number | undefined;
+  readonly exclusiveMinimum?: number | undefined;
+  readonly maxLength?: number | undefined;
+  readonly minLength?: number | undefined;
+  readonly pattern?: string | undefined;
+  readonly format?: string | undefined;
+  readonly maxItems?: number | undefined;
+  readonly minItems?: number | undefined;
+  readonly uniqueItems?: boolean | undefined;
+  readonly prefixItems?: ReadonlyArray<ResponseFormatNode> | undefined;
+  readonly properties?: Readonly<Record<string, ResponseFormatNode>> | undefined;
+  readonly patternProperties?: Readonly<Record<string, ResponseFormatNode>> | undefined;
+  readonly required?: ReadonlyArray<string> | undefined;
+  readonly dependentRequired?: Readonly<Record<string, ReadonlyArray<string>>> | undefined;
+  readonly dependentSchemas?: Readonly<Record<string, ResponseFormatNode>> | undefined;
+  readonly items?: ResponseFormatNode | boolean | undefined;
+  readonly additionalItems?: ResponseFormatNode | boolean | undefined;
+  readonly unevaluatedItems?: ResponseFormatNode | boolean | undefined;
+  readonly contains?: ResponseFormatNode | boolean | undefined;
+  readonly minContains?: number | undefined;
+  readonly maxContains?: number | undefined;
+  readonly additionalProperties?: ResponseFormatNode | boolean | undefined;
+  readonly unevaluatedProperties?: ResponseFormatNode | boolean | undefined;
+  readonly propertyNames?: ResponseFormatNode | boolean | undefined;
+  readonly minProperties?: number | undefined;
+  readonly maxProperties?: number | undefined;
+  readonly anyOf?: ReadonlyArray<ResponseFormatNode> | undefined;
+  readonly oneOf?: ReadonlyArray<ResponseFormatNode> | undefined;
+  readonly allOf?: ReadonlyArray<ResponseFormatNode> | undefined;
+  readonly not?: ResponseFormatNode | boolean | undefined;
+  readonly contentEncoding?: string | undefined;
+  readonly contentMediaType?: string | undefined;
+  readonly contentSchema?: ResponseFormatNode | boolean | undefined;
+  readonly $defs?: Readonly<Record<string, ResponseFormatNode>> | undefined;
+  readonly definitions?: Readonly<Record<string, ResponseFormatNode>> | undefined;
+};
+declare const ResponseFormatNode: Schema.Codec<ResponseFormatNode>;
+/** A platform-supported object JSON Schema with bounded depth, entries, nodes, and UTF-8 bytes. */
+declare const PageCaptureResponseFormat: Schema.declare<{
+  readonly $schema?: string | undefined;
+  readonly $id?: string | undefined;
+  readonly $ref?: string | undefined;
+  readonly $anchor?: string | undefined;
+  readonly $dynamicRef?: string | undefined;
+  readonly $dynamicAnchor?: string | undefined;
+  readonly $comment?: string | undefined;
+  readonly title?: string | undefined;
+  readonly description?: string | undefined;
+  readonly default?: Schema.Json | undefined;
+  readonly deprecated?: boolean | undefined;
+  readonly readOnly?: boolean | undefined;
+  readonly writeOnly?: boolean | undefined;
+  readonly examples?: readonly Schema.Json[] | undefined;
+  readonly enum?: readonly Schema.Json[] | undefined;
+  readonly const?: Schema.Json | undefined;
+  readonly multipleOf?: number | undefined;
+  readonly maximum?: number | undefined;
+  readonly exclusiveMaximum?: number | undefined;
+  readonly minimum?: number | undefined;
+  readonly exclusiveMinimum?: number | undefined;
+  readonly maxLength?: number | undefined;
+  readonly minLength?: number | undefined;
+  readonly pattern?: string | undefined;
+  readonly format?: string | undefined;
+  readonly maxItems?: number | undefined;
+  readonly minItems?: number | undefined;
+  readonly uniqueItems?: boolean | undefined;
+  readonly prefixItems?: readonly ResponseFormatNode[] | undefined;
+  readonly items?: boolean | ResponseFormatNode | undefined;
+  readonly additionalItems?: boolean | ResponseFormatNode | undefined;
+  readonly unevaluatedItems?: boolean | ResponseFormatNode | undefined;
+  readonly contains?: boolean | ResponseFormatNode | undefined;
+  readonly minContains?: number | undefined;
+  readonly maxContains?: number | undefined;
+  readonly properties?: {
+    readonly [x: string]: ResponseFormatNode;
+  } | undefined;
+  readonly patternProperties?: {
+    readonly [x: string]: ResponseFormatNode;
+  } | undefined;
+  readonly required?: readonly string[] | undefined;
+  readonly dependentRequired?: {
+    readonly [x: string]: readonly string[];
+  } | undefined;
+  readonly dependentSchemas?: {
+    readonly [x: string]: ResponseFormatNode;
+  } | undefined;
+  readonly additionalProperties?: boolean | ResponseFormatNode | undefined;
+  readonly unevaluatedProperties?: boolean | ResponseFormatNode | undefined;
+  readonly propertyNames?: boolean | ResponseFormatNode | undefined;
+  readonly minProperties?: number | undefined;
+  readonly maxProperties?: number | undefined;
+  readonly anyOf?: readonly ResponseFormatNode[] | undefined;
+  readonly oneOf?: readonly ResponseFormatNode[] | undefined;
+  readonly allOf?: readonly ResponseFormatNode[] | undefined;
+  readonly not?: boolean | ResponseFormatNode | undefined;
+  readonly contentEncoding?: string | undefined;
+  readonly contentMediaType?: string | undefined;
+  readonly contentSchema?: boolean | ResponseFormatNode | undefined;
+  readonly $defs?: {
+    readonly [x: string]: ResponseFormatNode;
+  } | undefined;
+  readonly definitions?: {
+    readonly [x: string]: ResponseFormatNode;
+  } | undefined;
+  readonly type: "object";
+}, {
+  readonly $schema?: string | undefined;
+  readonly $id?: string | undefined;
+  readonly $ref?: string | undefined;
+  readonly $anchor?: string | undefined;
+  readonly $dynamicRef?: string | undefined;
+  readonly $dynamicAnchor?: string | undefined;
+  readonly $comment?: string | undefined;
+  readonly title?: string | undefined;
+  readonly description?: string | undefined;
+  readonly default?: Schema.Json | undefined;
+  readonly deprecated?: boolean | undefined;
+  readonly readOnly?: boolean | undefined;
+  readonly writeOnly?: boolean | undefined;
+  readonly examples?: readonly Schema.Json[] | undefined;
+  readonly enum?: readonly Schema.Json[] | undefined;
+  readonly const?: Schema.Json | undefined;
+  readonly multipleOf?: number | undefined;
+  readonly maximum?: number | undefined;
+  readonly exclusiveMaximum?: number | undefined;
+  readonly minimum?: number | undefined;
+  readonly exclusiveMinimum?: number | undefined;
+  readonly maxLength?: number | undefined;
+  readonly minLength?: number | undefined;
+  readonly pattern?: string | undefined;
+  readonly format?: string | undefined;
+  readonly maxItems?: number | undefined;
+  readonly minItems?: number | undefined;
+  readonly uniqueItems?: boolean | undefined;
+  readonly prefixItems?: readonly ResponseFormatNode[] | undefined;
+  readonly items?: boolean | ResponseFormatNode | undefined;
+  readonly additionalItems?: boolean | ResponseFormatNode | undefined;
+  readonly unevaluatedItems?: boolean | ResponseFormatNode | undefined;
+  readonly contains?: boolean | ResponseFormatNode | undefined;
+  readonly minContains?: number | undefined;
+  readonly maxContains?: number | undefined;
+  readonly properties?: {
+    readonly [x: string]: ResponseFormatNode;
+  } | undefined;
+  readonly patternProperties?: {
+    readonly [x: string]: ResponseFormatNode;
+  } | undefined;
+  readonly required?: readonly string[] | undefined;
+  readonly dependentRequired?: {
+    readonly [x: string]: readonly string[];
+  } | undefined;
+  readonly dependentSchemas?: {
+    readonly [x: string]: ResponseFormatNode;
+  } | undefined;
+  readonly additionalProperties?: boolean | ResponseFormatNode | undefined;
+  readonly unevaluatedProperties?: boolean | ResponseFormatNode | undefined;
+  readonly propertyNames?: boolean | ResponseFormatNode | undefined;
+  readonly minProperties?: number | undefined;
+  readonly maxProperties?: number | undefined;
+  readonly anyOf?: readonly ResponseFormatNode[] | undefined;
+  readonly oneOf?: readonly ResponseFormatNode[] | undefined;
+  readonly allOf?: readonly ResponseFormatNode[] | undefined;
+  readonly not?: boolean | ResponseFormatNode | undefined;
+  readonly contentEncoding?: string | undefined;
+  readonly contentMediaType?: string | undefined;
+  readonly contentSchema?: boolean | ResponseFormatNode | undefined;
+  readonly $defs?: {
+    readonly [x: string]: ResponseFormatNode;
+  } | undefined;
+  readonly definitions?: {
+    readonly [x: string]: ResponseFormatNode;
+  } | undefined;
+  readonly type: "object";
+}>;
+type PageCaptureResponseFormat = typeof PageCaptureResponseFormat.Type;
+declare const PageUrlTarget_base: Schema.Class<PageUrlTarget, Schema.TaggedStruct<"PageUrlTarget", {
+  readonly url: Schema.NonEmptyString;
+}>, {}>;
+/** Capture a URL after a full render, the common case. */
+declare class PageUrlTarget extends PageUrlTarget_base {}
+declare const PageHtmlTarget_base: Schema.Class<PageHtmlTarget, Schema.TaggedStruct<"PageHtmlTarget", {
+  readonly html: Schema.NonEmptyString;
+}>, {}>;
+/** Render caller-supplied HTML instead of navigating. */
+declare class PageHtmlTarget extends PageHtmlTarget_base {}
+/** What the pass renders: a navigated URL or raw HTML. */
+declare const PageCaptureTarget: Schema.Union<readonly [typeof PageUrlTarget, typeof PageHtmlTarget]>;
+type PageCaptureTarget = typeof PageCaptureTarget.Type;
+/**
+ * The rendering engine. `chromium` is the full headless browser; `kitesurf`
+ * is a lightweight stateless engine an adapter may support for lower-cost
+ * captures. An adapter that cannot honor the requested engine
+ * rejects it typed rather than silently substituting the other.
+ */
+declare const PageCaptureEngine: Schema.Literals<readonly ["chromium", "kitesurf"]>;
+type PageCaptureEngine = typeof PageCaptureEngine.Type;
+declare const CapturePageContent_base: Schema.Class<CapturePageContent, Schema.TaggedStruct<"CapturePageContent", {}>, {}>;
+/** Return the fully rendered HTML document. */
+declare class CapturePageContent extends CapturePageContent_base {}
+declare const CapturePageMarkdown_base: Schema.Class<CapturePageMarkdown, Schema.TaggedStruct<"CapturePageMarkdown", {}>, {}>;
+/** Return the rendered page converted to Markdown. */
+declare class CapturePageMarkdown extends CapturePageMarkdown_base {}
+declare const CapturePageLinks_base: Schema.Class<CapturePageLinks, Schema.TaggedStruct<"CapturePageLinks", {
+  readonly visibleLinksOnly: Schema.optionalKey<Schema.Boolean>;
+}>, {}>;
+/** Return the hyperlinks discovered on the rendered page. */
+declare class CapturePageLinks extends CapturePageLinks_base {}
+declare const CapturePageScrape_base: Schema.Class<CapturePageScrape, Schema.TaggedStruct<"CapturePageScrape", {
+  readonly selectors: Schema.$Array<Schema.NonEmptyString>;
+}>, {}>;
+/** Return rendered element records grouped by their requested CSS selector. */
+declare class CapturePageScrape extends CapturePageScrape_base {}
+declare const CapturePageStructured_base: Schema.Class<CapturePageStructured, Schema.TaggedStruct<"CapturePageStructured", {
+  readonly responseFormat: Schema.declare<{
+    readonly $schema?: string | undefined;
+    readonly $id?: string | undefined;
+    readonly $ref?: string | undefined;
+    readonly $anchor?: string | undefined;
+    readonly $dynamicRef?: string | undefined;
+    readonly $dynamicAnchor?: string | undefined;
+    readonly $comment?: string | undefined;
+    readonly title?: string | undefined;
+    readonly description?: string | undefined;
+    readonly default?: Schema.Json | undefined;
+    readonly deprecated?: boolean | undefined;
+    readonly readOnly?: boolean | undefined;
+    readonly writeOnly?: boolean | undefined;
+    readonly examples?: readonly Schema.Json[] | undefined;
+    readonly enum?: readonly Schema.Json[] | undefined;
+    readonly const?: Schema.Json | undefined;
+    readonly multipleOf?: number | undefined;
+    readonly maximum?: number | undefined;
+    readonly exclusiveMaximum?: number | undefined;
+    readonly minimum?: number | undefined;
+    readonly exclusiveMinimum?: number | undefined;
+    readonly maxLength?: number | undefined;
+    readonly minLength?: number | undefined;
+    readonly pattern?: string | undefined;
+    readonly format?: string | undefined;
+    readonly maxItems?: number | undefined;
+    readonly minItems?: number | undefined;
+    readonly uniqueItems?: boolean | undefined;
+    readonly prefixItems?: readonly ResponseFormatNode[] | undefined;
+    readonly items?: boolean | ResponseFormatNode | undefined;
+    readonly additionalItems?: boolean | ResponseFormatNode | undefined;
+    readonly unevaluatedItems?: boolean | ResponseFormatNode | undefined;
+    readonly contains?: boolean | ResponseFormatNode | undefined;
+    readonly minContains?: number | undefined;
+    readonly maxContains?: number | undefined;
+    readonly properties?: {
+      readonly [x: string]: ResponseFormatNode;
+    } | undefined;
+    readonly patternProperties?: {
+      readonly [x: string]: ResponseFormatNode;
+    } | undefined;
+    readonly required?: readonly string[] | undefined;
+    readonly dependentRequired?: {
+      readonly [x: string]: readonly string[];
+    } | undefined;
+    readonly dependentSchemas?: {
+      readonly [x: string]: ResponseFormatNode;
+    } | undefined;
+    readonly additionalProperties?: boolean | ResponseFormatNode | undefined;
+    readonly unevaluatedProperties?: boolean | ResponseFormatNode | undefined;
+    readonly propertyNames?: boolean | ResponseFormatNode | undefined;
+    readonly minProperties?: number | undefined;
+    readonly maxProperties?: number | undefined;
+    readonly anyOf?: readonly ResponseFormatNode[] | undefined;
+    readonly oneOf?: readonly ResponseFormatNode[] | undefined;
+    readonly allOf?: readonly ResponseFormatNode[] | undefined;
+    readonly not?: boolean | ResponseFormatNode | undefined;
+    readonly contentEncoding?: string | undefined;
+    readonly contentMediaType?: string | undefined;
+    readonly contentSchema?: boolean | ResponseFormatNode | undefined;
+    readonly $defs?: {
+      readonly [x: string]: ResponseFormatNode;
+    } | undefined;
+    readonly definitions?: {
+      readonly [x: string]: ResponseFormatNode;
+    } | undefined;
+    readonly type: "object";
+  }, {
+    readonly $schema?: string | undefined;
+    readonly $id?: string | undefined;
+    readonly $ref?: string | undefined;
+    readonly $anchor?: string | undefined;
+    readonly $dynamicRef?: string | undefined;
+    readonly $dynamicAnchor?: string | undefined;
+    readonly $comment?: string | undefined;
+    readonly title?: string | undefined;
+    readonly description?: string | undefined;
+    readonly default?: Schema.Json | undefined;
+    readonly deprecated?: boolean | undefined;
+    readonly readOnly?: boolean | undefined;
+    readonly writeOnly?: boolean | undefined;
+    readonly examples?: readonly Schema.Json[] | undefined;
+    readonly enum?: readonly Schema.Json[] | undefined;
+    readonly const?: Schema.Json | undefined;
+    readonly multipleOf?: number | undefined;
+    readonly maximum?: number | undefined;
+    readonly exclusiveMaximum?: number | undefined;
+    readonly minimum?: number | undefined;
+    readonly exclusiveMinimum?: number | undefined;
+    readonly maxLength?: number | undefined;
+    readonly minLength?: number | undefined;
+    readonly pattern?: string | undefined;
+    readonly format?: string | undefined;
+    readonly maxItems?: number | undefined;
+    readonly minItems?: number | undefined;
+    readonly uniqueItems?: boolean | undefined;
+    readonly prefixItems?: readonly ResponseFormatNode[] | undefined;
+    readonly items?: boolean | ResponseFormatNode | undefined;
+    readonly additionalItems?: boolean | ResponseFormatNode | undefined;
+    readonly unevaluatedItems?: boolean | ResponseFormatNode | undefined;
+    readonly contains?: boolean | ResponseFormatNode | undefined;
+    readonly minContains?: number | undefined;
+    readonly maxContains?: number | undefined;
+    readonly properties?: {
+      readonly [x: string]: ResponseFormatNode;
+    } | undefined;
+    readonly patternProperties?: {
+      readonly [x: string]: ResponseFormatNode;
+    } | undefined;
+    readonly required?: readonly string[] | undefined;
+    readonly dependentRequired?: {
+      readonly [x: string]: readonly string[];
+    } | undefined;
+    readonly dependentSchemas?: {
+      readonly [x: string]: ResponseFormatNode;
+    } | undefined;
+    readonly additionalProperties?: boolean | ResponseFormatNode | undefined;
+    readonly unevaluatedProperties?: boolean | ResponseFormatNode | undefined;
+    readonly propertyNames?: boolean | ResponseFormatNode | undefined;
+    readonly minProperties?: number | undefined;
+    readonly maxProperties?: number | undefined;
+    readonly anyOf?: readonly ResponseFormatNode[] | undefined;
+    readonly oneOf?: readonly ResponseFormatNode[] | undefined;
+    readonly allOf?: readonly ResponseFormatNode[] | undefined;
+    readonly not?: boolean | ResponseFormatNode | undefined;
+    readonly contentEncoding?: string | undefined;
+    readonly contentMediaType?: string | undefined;
+    readonly contentSchema?: boolean | ResponseFormatNode | undefined;
+    readonly $defs?: {
+      readonly [x: string]: ResponseFormatNode;
+    } | undefined;
+    readonly definitions?: {
+      readonly [x: string]: ResponseFormatNode;
+    } | undefined;
+    readonly type: "object";
+  }>;
+  readonly prompt: Schema.optionalKey<Schema.NonEmptyString>;
+}>, {}>;
+/**
+ * Extract structured data from the rendered page. `responseFormat` is a
+ * bounded, object-shaped JSON Schema document, typically derived from an
+ * Effect Schema. The untrusted result must still be decoded by the caller
+ * through the original Effect Schema.
+ */
+declare class CapturePageStructured extends CapturePageStructured_base {}
+/** Exactly one bounded output per pass. */
+declare const PageCaptureAction: Schema.Union<readonly [typeof CapturePageContent, typeof CapturePageMarkdown, typeof CapturePageLinks, typeof CapturePageScrape, typeof CapturePageStructured]>;
+type PageCaptureAction = typeof PageCaptureAction.Type;
+declare const PageSelectorWait_base: Schema.Class<PageSelectorWait, Schema.Struct<{
+  readonly selector: Schema.NonEmptyString;
+  readonly timeoutMillis: Schema.optionalKey<Schema.Int>;
+}>, {}>;
+/** Wait for one CSS selector to appear before capturing. */
+declare class PageSelectorWait extends PageSelectorWait_base {}
+declare const PageNavigationOptions_base: Schema.Class<PageNavigationOptions, Schema.Struct<{
+  readonly waitUntil: Schema.optionalKey<Schema.Literals<readonly ["load", "domcontentloaded", "networkidle0", "networkidle2"]>>;
+  readonly timeoutMillis: Schema.optionalKey<Schema.Int>;
+  readonly waitForSelector: Schema.optionalKey<typeof PageSelectorWait>;
+}>, {}>;
+/** Navigation and readiness options applied before the capture. */
+declare class PageNavigationOptions extends PageNavigationOptions_base {}
+declare const PageViewport_base: Schema.Class<PageViewport, Schema.Struct<{
+  readonly width: Schema.Int;
+  readonly height: Schema.Int;
+}>, {}>;
+/** The rendered viewport. */
+declare class PageViewport extends PageViewport_base {}
+declare const PageResourcePolicy_base: Schema.Class<PageResourcePolicy, Schema.Struct<{
+  readonly rejectResourceTypes: Schema.optionalKey<Schema.$Array<Schema.Literals<readonly ["document", "stylesheet", "image", "media", "font", "script", "texttrack", "xhr", "fetch", "eventsource", "websocket", "manifest", "other"]>>>;
+  readonly allowRequestPatterns: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+}>, {}>;
+/**
+ * Request egress policy for the render. Rejected resource types are never
+ * fetched; when request patterns are given, only matching navigation,
+ * redirect, and subresource requests are allowed. Calling capabilities own
+ * the capture-target allowlist and project it into this policy so rendered
+ * JavaScript cannot escape the same construction-time authority.
+ */
+declare class PageResourcePolicy extends PageResourcePolicy_base {}
+declare const PageCaptureLimits_base: Schema.Class<PageCaptureLimits, Schema.Struct<{
+  readonly maxOutputBytes: Schema.Int;
+}>, {}>;
+/** Limits an adapter must either enforce or reject. Bytes are UTF-8 encoded. */
+declare class PageCaptureLimits extends PageCaptureLimits_base {}
+declare const PageCaptureRequest_base: Schema.Class<PageCaptureRequest, Schema.Struct<{
+  readonly target: Schema.Union<readonly [typeof PageUrlTarget, typeof PageHtmlTarget]>;
+  readonly action: Schema.Union<readonly [typeof CapturePageContent, typeof CapturePageMarkdown, typeof CapturePageLinks, typeof CapturePageScrape, typeof CapturePageStructured]>;
+  readonly engine: Schema.Literals<readonly ["chromium", "kitesurf"]>;
+  readonly limits: typeof PageCaptureLimits;
+  readonly navigation: Schema.optionalKey<typeof PageNavigationOptions>;
+  readonly viewport: Schema.optionalKey<typeof PageViewport>;
+  readonly resourcePolicy: Schema.optionalKey<typeof PageResourcePolicy>;
+}>, {}>;
+/** Schema-first page capture request: one target, one action, one output. */
+declare class PageCaptureRequest extends PageCaptureRequest_base {}
+declare const PageContentCaptured_base: Schema.Class<PageContentCaptured, Schema.TaggedStruct<"PageContentCaptured", {
+  readonly html: Schema.String;
+}>, {}>;
+/** The rendered HTML document. */
+declare class PageContentCaptured extends PageContentCaptured_base {}
+declare const PageMarkdownCaptured_base: Schema.Class<PageMarkdownCaptured, Schema.TaggedStruct<"PageMarkdownCaptured", {
+  readonly markdown: Schema.String;
+}>, {}>;
+/** The rendered page as Markdown. */
+declare class PageMarkdownCaptured extends PageMarkdownCaptured_base {}
+declare const PageLinksCaptured_base: Schema.Class<PageLinksCaptured, Schema.TaggedStruct<"PageLinksCaptured", {
+  readonly links: Schema.$Array<Schema.NonEmptyString>;
+}>, {}>;
+/** The hyperlinks discovered on the rendered page. */
+declare class PageLinksCaptured extends PageLinksCaptured_base {}
+declare const PageStructuredCaptured_base: Schema.Class<PageStructuredCaptured, Schema.TaggedStruct<"PageStructuredCaptured", {
+  readonly value: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+}>, {}>;
+/** The extracted structured value; untrusted until decoded by the caller. */
+declare class PageStructuredCaptured extends PageStructuredCaptured_base {}
+declare const PageScrapeAttribute_base: Schema.Class<PageScrapeAttribute, Schema.Struct<{
+  readonly name: Schema.NonEmptyString;
+  readonly value: Schema.String;
+}>, {}>;
+/** One bounded HTML attribute returned by a selector scrape. */
+declare class PageScrapeAttribute extends PageScrapeAttribute_base {}
+declare const PageScrapeElement_base: Schema.Class<PageScrapeElement, Schema.Struct<{
+  readonly text: Schema.String;
+  readonly html: Schema.String;
+  readonly attributes: Schema.$Array<typeof PageScrapeAttribute>;
+  readonly left: Schema.Finite;
+  readonly top: Schema.Finite;
+  readonly width: Schema.Finite;
+  readonly height: Schema.Finite;
+}>, {}>;
+/** One rendered element returned by a selector scrape. */
+declare class PageScrapeElement extends PageScrapeElement_base {}
+declare const PageScrapeGroup_base: Schema.Class<PageScrapeGroup, Schema.Struct<{
+  readonly selector: Schema.NonEmptyString;
+  readonly results: Schema.$Array<typeof PageScrapeElement>;
+}>, {}>;
+/** All rendered elements matched by one requested selector. */
+declare class PageScrapeGroup extends PageScrapeGroup_base {}
+declare const PageScrapeCaptured_base: Schema.Class<PageScrapeCaptured, Schema.TaggedStruct<"PageScrapeCaptured", {
+  readonly groups: Schema.$Array<typeof PageScrapeGroup>;
+}>, {}>;
+/** Bounded rendered element records, preserving selector grouping. */
+declare class PageScrapeCaptured extends PageScrapeCaptured_base {}
+/** Exactly one output kind per pass, matching the requested action. */
+declare const PageCaptureOutput: Schema.Union<readonly [typeof PageContentCaptured, typeof PageMarkdownCaptured, typeof PageLinksCaptured, typeof PageScrapeCaptured, typeof PageStructuredCaptured]>;
+type PageCaptureOutput = typeof PageCaptureOutput.Type;
+declare const PageCaptureInferenceUse_base: Schema.Class<PageCaptureInferenceUse, Schema.Struct<{
+  readonly provider: Schema.NonEmptyString;
+  readonly modelCalls: Schema.Int;
+}>, {}>;
+/** Explicit accounting for model inference performed by a capture adapter. */
+declare class PageCaptureInferenceUse extends PageCaptureInferenceUse_base {}
+declare const PageCaptureResourceUse_base: Schema.Class<PageCaptureResourceUse, Schema.Struct<{
+  readonly browserMillis: Schema.optionalKey<Schema.Natural>;
+  readonly inference: Schema.optionalKey<typeof PageCaptureInferenceUse>;
+}>, {}>;
+/** Accounting an adapter observed for one capture. */
+declare class PageCaptureResourceUse extends PageCaptureResourceUse_base {}
+declare const PageCaptureResult_base: Schema.Class<PageCaptureResult, Schema.Struct<{
+  readonly implementation: typeof SandboxImplementation;
+  readonly output: Schema.Union<readonly [typeof PageContentCaptured, typeof PageMarkdownCaptured, typeof PageLinksCaptured, typeof PageScrapeCaptured, typeof PageStructuredCaptured]>;
+  readonly resourceUse: typeof PageCaptureResourceUse;
+}>, {}>;
+/** The bounded outcome of one capture pass. */
+declare class PageCaptureResult extends PageCaptureResult_base {}
+declare const PageCaptureRateLimitedError_base: Schema.Class<PageCaptureRateLimitedError, Schema.TaggedStruct<"PageCaptureRateLimitedError", {
+  readonly implementation: typeof SandboxImplementation;
+  readonly reason: Schema.Literals<readonly ["rate", "quota"]>;
+  readonly retryAfterMillis: Schema.optionalKey<Schema.Natural>;
+  readonly message: Schema.String;
+  readonly cause: Schema.optionalKey<Schema.Defect>;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * The platform refused the pass for rate or quota reasons. `retryAfterMillis`
+ * carries the platform's own backoff hint when one exists; retrying earlier
+ * only re-fails.
+ */
+declare class PageCaptureRateLimitedError extends PageCaptureRateLimitedError_base {}
+declare const PageCaptureNavigationError_base: Schema.Class<PageCaptureNavigationError, Schema.TaggedStruct<"PageCaptureNavigationError", {
+  readonly implementation: typeof SandboxImplementation;
+  readonly message: Schema.String;
+  readonly cause: Schema.optionalKey<Schema.Defect>;
+}>, import("effect/Cause").YieldableError>;
+/** Navigation, readiness, or capture of the target page failed. */
+declare class PageCaptureNavigationError extends PageCaptureNavigationError_base {}
+declare const PageCaptureInferencePolicyError_base: Schema.Class<PageCaptureInferencePolicyError, Schema.TaggedStruct<"PageCaptureInferencePolicyError", {
+  readonly implementation: typeof SandboxImplementation;
+  readonly provider: Schema.NonEmptyString;
+  readonly reason: Schema.Literals<readonly ["authorization", "accounting"]>;
+  readonly message: Schema.String;
+  readonly cause: Schema.optionalKey<Schema.Defect>;
+}>, import("effect/Cause").YieldableError>;
+/** Host authorization or accounting blocked provider inference before capture. */
+declare class PageCaptureInferencePolicyError extends PageCaptureInferencePolicyError_base {}
+declare const PageCaptureUnsupportedError_base: Schema.Class<PageCaptureUnsupportedError, Schema.TaggedStruct<"PageCaptureUnsupportedError", {
+  readonly implementation: typeof SandboxImplementation;
+  readonly feature: Schema.Literals<readonly ["engine", "action", "target", "navigation", "viewport", "resource-policy"]>;
+  readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** The adapter cannot honestly honor one requested feature (CAP-010 idiom). */
+declare class PageCaptureUnsupportedError extends PageCaptureUnsupportedError_base {}
+declare const PageCaptureOutputLimitError_base: Schema.Class<PageCaptureOutputLimitError, Schema.TaggedStruct<"PageCaptureOutputLimitError", {
+  readonly implementation: typeof SandboxImplementation;
+  readonly limit: Schema.Int;
+  readonly observed: Schema.Natural;
+}>, import("effect/Cause").YieldableError>;
+/** The response exceeded the request's output byte budget. */
+declare class PageCaptureOutputLimitError extends PageCaptureOutputLimitError_base {}
+declare const PageCaptureProtocolError_base: Schema.Class<PageCaptureProtocolError, Schema.TaggedStruct<"PageCaptureProtocolError", {
+  readonly implementation: typeof SandboxImplementation;
+  readonly message: Schema.String;
+  readonly cause: Schema.optionalKey<Schema.Defect>;
+}>, import("effect/Cause").YieldableError>;
+/** The platform or transport produced a value outside the capture protocol. */
+declare class PageCaptureProtocolError extends PageCaptureProtocolError_base {}
+/** Expected capture failures. Interruption stays an Effect interruption. */
+declare const PageCaptureError: Schema.Union<readonly [typeof PageCaptureRateLimitedError, typeof PageCaptureNavigationError, typeof PageCaptureInferencePolicyError, typeof PageCaptureUnsupportedError, typeof PageCaptureOutputLimitError, typeof PageCaptureProtocolError]>;
+type PageCaptureError = typeof PageCaptureError.Type;
+declare const PageCapture_base: Context.ServiceClass<PageCapture, "@effect-agent/sandbox/PageCapture", {
+  readonly capture: (request: PageCaptureRequest) => Effect.Effect<PageCaptureResult, PageCaptureError>;
+}>;
+/**
+ * Stateless page-capture port. One `capture` is one pass: the adapter owns no
+ * session, replay, approval, or Thread semantics, identifies its
+ * isolation posture honestly (CAP-010), enforces or rejects every requested
+ * limit and policy, and returns exactly one bounded output. Capture results
+ * are untrusted input to whatever reads them.
+ */
+declare class PageCapture extends PageCapture_base {}
+/** Type helper for implementations that preserve the public PageCapture contract. */
+type PageCaptureCapture = (request: PageCaptureRequest) => Effect.Effect<PageCaptureResult, PageCaptureError>;
+//#endregion
+export { PageLinksCaptured as A, PageUrlTarget as B, PageCaptureResult as C, PageCapture_d_exports as D, PageCaptureUnsupportedError as E, PageScrapeCaptured as F, PageScrapeElement as I, PageScrapeGroup as L, PageNavigationOptions as M, PageResourcePolicy as N, PageContentCaptured as O, PageScrapeAttribute as P, PageSelectorWait as R, PageCaptureResponseFormat as S, PageCaptureTargetUrl as T, PageViewport as V, PageCaptureOutputLimitError as _, CapturePageStructured as a, PageCaptureRequest as b, PageCaptureCapture as c, PageCaptureInferencePolicyError as d, PageCaptureInferenceUse as f, PageCaptureOutput as g, PageCaptureNavigationError as h, CapturePageScrape as i, PageMarkdownCaptured as j, PageHtmlTarget as k, PageCaptureEngine as l, PageCaptureLinkUrl as m, CapturePageLinks as n, PageCapture as o, PageCaptureLimits as p, CapturePageMarkdown as r, PageCaptureAction as s, CapturePageContent as t, PageCaptureError as u, PageCaptureProtocolError as v, PageCaptureTarget as w, PageCaptureResourceUse as x, PageCaptureRateLimitedError as y, PageStructuredCaptured as z };
+//# sourceMappingURL=PageCapture-Df8Xwskw.d.mts.map

package/dist/PageScreenshot-BpgZKAxl.d.mts

@@ -0,0 +1,48 @@
+import { p as SandboxImplementation } from "./Sandbox-CEsDWBLq.mjs";
+import { B as PageUrlTarget, E as PageCaptureUnsupportedError, M as PageNavigationOptions, N as PageResourcePolicy, V as PageViewport, h as PageCaptureNavigationError, k as PageHtmlTarget, v as PageCaptureProtocolError, y as PageCaptureRateLimitedError } from "./PageCapture-Df8Xwskw.mjs";
+import { Context, Effect, Schema } from "effect";
+declare namespace PageScreenshot_d_exports {
+  export { PageScreenshot, PageScreenshotCapture, PageScreenshotError, PageScreenshotLimits, PageScreenshotOutputLimitError, PageScreenshotRequest, PageScreenshotResult };
+}
+declare const PageScreenshotLimits_base: Schema.Class<PageScreenshotLimits, Schema.Struct<{
+  readonly maxOutputBytes: Schema.Int;
+}>, {}>;
+/** The byte limit and full-page choice are fixed before Browser Run starts. */
+declare class PageScreenshotLimits extends PageScreenshotLimits_base {}
+declare const PageScreenshotRequest_base: Schema.Class<PageScreenshotRequest, Schema.Struct<{
+  readonly target: Schema.Union<readonly [typeof PageUrlTarget, typeof PageHtmlTarget]>;
+  readonly engine: Schema.Literals<readonly ["chromium", "kitesurf"]>;
+  readonly limits: typeof PageScreenshotLimits;
+  readonly fullPage: Schema.Boolean;
+  readonly navigation: Schema.optionalKey<typeof PageNavigationOptions>;
+  readonly viewport: Schema.optionalKey<typeof PageViewport>;
+  readonly resourcePolicy: Schema.optionalKey<typeof PageResourcePolicy>;
+}>, {}>;
+/** Schema-first request for exactly one PNG screenshot. */
+declare class PageScreenshotRequest extends PageScreenshotRequest_base {}
+declare const PageScreenshotResult_base: Schema.Class<PageScreenshotResult, Schema.Struct<{
+  readonly implementation: typeof SandboxImplementation;
+  readonly mediaType: Schema.Literal<"image/png">;
+  readonly bytes: Schema.Uint8Array;
+}>, {}>;
+/** The only successful output: bytes are caller-owned and never durable framework data. */
+declare class PageScreenshotResult extends PageScreenshotResult_base {}
+declare const PageScreenshotOutputLimitError_base: Schema.Class<PageScreenshotOutputLimitError, Schema.TaggedStruct<"PageScreenshotOutputLimitError", {
+  readonly implementation: typeof SandboxImplementation;
+  readonly limit: Schema.Int;
+  readonly observed: Schema.Natural;
+}>, import("effect/Cause").YieldableError>;
+/** The response crossed the request's PNG byte limit. */
+declare class PageScreenshotOutputLimitError extends PageScreenshotOutputLimitError_base {}
+/** Expected screenshot failures. The shared capture errors keep identical semantics. */
+declare const PageScreenshotError: Schema.Union<readonly [typeof PageCaptureRateLimitedError, typeof PageCaptureNavigationError, typeof PageCaptureUnsupportedError, typeof PageCaptureProtocolError, typeof PageScreenshotOutputLimitError]>;
+type PageScreenshotError = typeof PageScreenshotError.Type;
+declare const PageScreenshot_base: Context.ServiceClass<PageScreenshot, "@effect-agent/sandbox/PageScreenshot", {
+  readonly capture: (request: PageScreenshotRequest) => Effect.Effect<PageScreenshotResult, PageScreenshotError>;
+}>;
+/** Stateless, one-output PNG capture port. It owns neither persistence nor later byte handoff. */
+declare class PageScreenshot extends PageScreenshot_base {}
+type PageScreenshotCapture = (request: PageScreenshotRequest) => Effect.Effect<PageScreenshotResult, PageScreenshotError>;
+//#endregion
+export { PageScreenshotOutputLimitError as a, PageScreenshot_d_exports as c, PageScreenshotLimits as i, PageScreenshotCapture as n, PageScreenshotRequest as o, PageScreenshotError as r, PageScreenshotResult as s, PageScreenshot as t };
+//# sourceMappingURL=PageScreenshot-BpgZKAxl.d.mts.map