effect-browserbase 0.1.0-beta.102

package/dist/Capture-Dr5MkIJb.d.mts

@@ -0,0 +1,125 @@
+import { BrowserError } from "./Errors.mjs";
+import { E as PageInfo, L as Target } from "./BrowserData-LpcAuAub.mjs";
+import { BrowserbaseSession } from "./Browser.mjs";
+import { Effect, Schema, Scope, Stream } from "effect";
+//#region src/internal/capture/CaptureTypes.d.ts
+/**
+ * Binary frame data, not a live capability or a JSON/thread/Tool value. Decoding validates
+ * fields; it does not copy bytes, decode JPEG pixels, prove target authority, or repair clocks.
+ * Capture itself owns the byte copy, freezes its shared target identity, and verifies JPEG framing.
+ */
+declare const CapturedFrame: Schema.Struct<{
+  readonly bytes: Schema.Uint8Array;
+  readonly mediaType: Schema.Literal<"image/jpeg">;
+  readonly target: typeof Target;
+  readonly sequence: Schema.Natural;
+  /**
+   * Which document of its page this frame was received during: 0 at the start, one more for each
+   * main-frame navigation the interval observed. It is attribution by receipt order, not proof
+   * of whose pixels these are: a frame received just after a navigation can still show the
+   * document before it. Always 0 for an interval that lasts one document.
+   */
+  readonly document: Schema.Natural;
+  readonly sourceTimeMillis: Schema.Finite;
+  readonly sourceClock: Schema.Literal<"presentation-unix-millis">;
+  readonly receivedMonotonicNanos: Schema.BigInt;
+  readonly width: Schema.Int;
+  readonly height: Schema.Int;
+  readonly viewportWidth: Schema.Int;
+  readonly viewportHeight: Schema.Int;
+}>;
+type CapturedFrame = typeof CapturedFrame.Type;
+/** Source-fit request in pixels. Actual JPEG bounds are checked before any frame is delivered. */
+declare const CaptureSize: Schema.Struct<{
+  readonly width: Schema.Int;
+  readonly height: Schema.Int;
+}>;
+type CaptureSize = typeof CaptureSize.Type;
+/** Optional capture data. Defaults are applied at admission, not during schema decoding. */
+declare const CaptureOptions: Schema.Struct<{
+  /** Pin to a page from `session.pages`; omission preserves selected-page behavior. */
+  readonly target: Schema.optionalKey<typeof PageInfo>;
+  readonly maxFrames: Schema.optionalKey<Schema.Int>;
+  readonly maxBufferedBytes: Schema.optionalKey<Schema.Int>;
+  readonly maxFrameBytes: Schema.optionalKey<Schema.Int>;
+  readonly maxDurationMillis: Schema.optionalKey<Schema.Int>;
+  readonly quality: Schema.optionalKey<Schema.Int>;
+  /** Source fit only. Does not resize the viewport or impose an FPS cap. */
+  readonly size: Schema.optionalKey<Schema.Struct<{
+    readonly width: Schema.Int;
+    readonly height: Schema.Int;
+  }>>;
+  /**
+   * `document`, the default, ends the interval when its page navigates. `page` follows the page
+   * across documents, so a capture started before a navigation covers the loading in between.
+   * It applies to a page's main frame; a capture bound to a child frame still ends with it.
+   */
+  readonly lifetime: Schema.optionalKey<Schema.Literals<readonly ["document", "page"]>>;
+}>;
+type CaptureOptions = typeof CaptureOptions.Type;
+declare const CaptureSummary_base: Schema.Class<CaptureSummary, Schema.Struct<{
+  readonly target: typeof Target;
+  readonly reason: Schema.String;
+  readonly received: Schema.Natural;
+  readonly delivered: Schema.Natural;
+  readonly dropped: Schema.Natural;
+  readonly duplicates: Schema.Natural;
+  /** Arrived after a newer frame was accepted; counted within `dropped`, never reordered in. */
+  readonly late: Schema.Natural;
+  readonly peakBufferedFrames: Schema.Natural;
+  readonly peakBufferedBytes: Schema.Natural;
+  readonly bufferedFrames: Schema.Natural;
+  readonly bufferedBytes: Schema.Natural;
+  readonly sourceFirstMillis: Schema.NullOr<Schema.Finite>;
+  readonly sourceLastMillis: Schema.NullOr<Schema.Finite>;
+  /**
+   * The captured frame's address when this interval began watching it: the URL of document 0.
+   * It is read in the same turn the watch is installed, so no navigation can fall between them.
+   */
+  readonly initialUrl: Schema.NullOr<Schema.String>;
+  /**
+   * Each main-frame navigation a `page` interval observed, in order, with the last frame
+   * received before it and the address the new document committed. The native screencast is
+   * never restarted for one, so a boundary is not a gap this package introduced; what Chromium
+   * omitted while loading stays `upstreamDrops`. A boundary is the commit. When that navigation
+   * started and when its document finished loading are the caller's to stamp, on this same
+   * clock, around the operation that caused it. A title is page state, not part of a transition.
+   */
+  readonly documentBoundaries: Schema.$Array<Schema.Struct<{
+    readonly document: Schema.Natural;
+    readonly observedMonotonicNanos: Schema.BigInt;
+    readonly afterSequence: Schema.NullOr<Schema.Natural>;
+    readonly url: Schema.NullOr<Schema.String>;
+  }>>;
+  /** More navigations were observed than are recorded above. Frames still count them all. */
+  readonly documentBoundariesTruncated: Schema.Boolean;
+  readonly nativeStop: Schema.Literals<readonly ["confirmed", "unconfirmed"]>;
+  /** Package accounting cannot measure frames omitted by Chromium, transport, or the provider. */
+  readonly upstreamDrops: Schema.Literal<"unknown">;
+  readonly error: Schema.optionalKey<typeof BrowserError>;
+}>, {}>;
+declare class CaptureSummary extends CaptureSummary_base {}
+/** Live stream/Effect capabilities intentionally have no data schema or serialization contract. */
+interface CaptureInterval {
+  /** Single subscription. Ending or interrupting it stops this interval, not its browser. */
+  readonly frames: Stream.Stream<CapturedFrame, BrowserError>;
+  readonly stop: Effect.Effect<CaptureSummary>;
+  readonly completed: Effect.Effect<CaptureSummary>;
+}
+declare namespace Capture_d_exports {
+  export { CaptureInterval, CaptureOptions, CaptureSize, CaptureSummary, CapturedFrame, start };
+}
+/**
+ * Capture one remote page independently of the session's selected page.
+ *
+ * Requires the exact live session returned by the host; copying a session object or decoding
+ * a durable reference cannot copy its capture authority. The private owner is not frame data.
+ * `CapturedFrame` and `CaptureOptions` are Schema values as well as structural types. Frame
+ * decoding checks binary/metadata fields, not the complete JPEG bitstream or target authority,
+ * and does not copy bytes. Options decoding preserves omissions; admission applies defaults.
+ * `CaptureInterval` remains a live scoped capability, not a schema or JSON/Tool value.
+ */
+declare const start: <E>(session: BrowserbaseSession<E>, options?: CaptureOptions) => Effect.Effect<CaptureInterval, BrowserError, Scope.Scope>;
+//#endregion
+export { CaptureSize as a, CaptureOptions as i, start as n, CaptureSummary as o, CaptureInterval as r, CapturedFrame as s, Capture_d_exports as t };
+//# sourceMappingURL=Capture-Dr5MkIJb.d.mts.map

package/dist/Capture.d.mts

@@ -0,0 +1,2 @@
+import { a as CaptureSize, i as CaptureOptions, n as start, o as CaptureSummary, r as CaptureInterval, s as CapturedFrame } from "./Capture-Dr5MkIJb.mjs";
+export { type CaptureInterval, CaptureOptions, CaptureSize, CaptureSummary, CapturedFrame, start };

package/dist/Capture.mjs

@@ -0,0 +1,2 @@
+import { a as CaptureSummary, i as CaptureSize, n as start, o as CapturedFrame, r as CaptureOptions } from "./Capture-CZJPuD7b.mjs";
+export { CaptureOptions, CaptureSize, CaptureSummary, CapturedFrame, start };

package/dist/Certificates.d.mts

@@ -0,0 +1,35 @@
+import { CertificateError } from "./Errors.mjs";
+import { t as BrowserbaseClient } from "./Client-Ca0zSg1n.mjs";
+import { Context, Effect, Layer, Schema } from "effect";
+declare namespace Certificates_d_exports {
+  export { BrowserbaseCertificates, CertificateMetadata, CertificateUpload };
+}
+declare const CertificateMetadata_base: Schema.Class<CertificateMetadata, Schema.Struct<{
+  readonly certificateId: Schema.NonEmptyString;
+  readonly projectId: Schema.NonEmptyString;
+  readonly createdAt: Schema.String;
+  readonly updatedAt: Schema.String;
+}>, {}>;
+/** Select a certificate at launch with `provider.proxySettings.caCertificates: [certificateId]`. */
+export declare class CertificateMetadata extends CertificateMetadata_base {}
+export interface CertificateUpload {
+  /** PEM or DER bytes of one CA certificate. */
+  readonly bytes: Uint8Array;
+  /** Portable basename sent with the part; defaults to `certificate.pem`. */
+  readonly filename?: string;
+  readonly maxBytes?: number;
+  readonly timeoutMillis?: number;
+}
+declare const BrowserbaseCertificates_base: Context.ServiceClass<BrowserbaseCertificates, "effect-browserbase/Certificates", {
+  readonly create: (upload: CertificateUpload) => Effect.Effect<CertificateMetadata, CertificateError>;
+  readonly list: Effect.Effect<ReadonlyArray<CertificateMetadata>, CertificateError>;
+  readonly retrieve: (certificateId: string) => Effect.Effect<CertificateMetadata, CertificateError>;
+  readonly delete: (certificateId: string) => Effect.Effect<void, CertificateError>;
+}>;
+/** Proxy CA certificates. Registration is one bounded multipart mutation, never retried. */
+export declare class BrowserbaseCertificates extends BrowserbaseCertificates_base {
+  static readonly layer: Layer.Layer<BrowserbaseCertificates, never, BrowserbaseClient>;
+}
+//#endregion
+export { Certificates_d_exports as t };
+//# sourceMappingURL=Certificates.d.mts.map

package/dist/Certificates.mjs

@@ -0,0 +1,90 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
+import { Identifier } from "./References.mjs";
+import { CertificateError } from "./Errors.mjs";
+import { SafeFilename } from "./Transfers.mjs";
+import { t as BrowserbaseClient } from "./Client-D1_xYM9o.mjs";
+import { t as resource } from "./Resource-DBksC4zB.mjs";
+import { Context, Effect, Layer, Schema } from "effect";
+//#region src/Certificates.ts
+var Certificates_exports = /* @__PURE__ */ __exportAll({
+	BrowserbaseCertificates: () => BrowserbaseCertificates,
+	CertificateMetadata: () => CertificateMetadata
+});
+const Timestamp = Schema.String.check(Schema.isMaxLength(64));
+const MAX_CERTIFICATE_BYTES = 1048576;
+/** Select a certificate at launch with `provider.proxySettings.caCertificates: [certificateId]`. */
+var CertificateMetadata = class extends Schema.Class("BrowserbaseCertificateMetadata")({
+	certificateId: Identifier,
+	projectId: Identifier,
+	createdAt: Timestamp,
+	updatedAt: Timestamp
+}) {};
+const Upload = Schema.Struct({
+	filename: Schema.optionalKey(SafeFilename),
+	maxBytes: Schema.optionalKey(Schema.Int.check(Schema.isBetween({
+		minimum: 1,
+		maximum: MAX_CERTIFICATE_BYTES
+	}))),
+	timeoutMillis: Schema.optionalKey(Schema.Int.check(Schema.isBetween({
+		minimum: 1,
+		maximum: 6e5
+	})))
+});
+const ProviderCertificate = Schema.Struct({
+	id: Identifier,
+	projectId: Identifier,
+	createdAt: Timestamp,
+	updatedAt: Timestamp
+});
+/** Proxy CA certificates. Registration is one bounded multipart mutation, never retried. */
+var BrowserbaseCertificates = class BrowserbaseCertificates extends Context.Service()("effect-browserbase/Certificates") {
+	static layer = Layer.effect(BrowserbaseCertificates, Effect.gen(function* () {
+		const client = yield* BrowserbaseClient;
+		const api = resource(client, (failure) => CertificateError.make(failure));
+		const own = (operation, mutation) => Effect.fnUntraced(function* (value) {
+			if (value.projectId !== client.projectId) return yield* api.malformed(operation, mutation);
+			const { id, ...rest } = value;
+			return CertificateMetadata.make({
+				certificateId: id,
+				...rest
+			});
+		});
+		const create = Effect.fn("BrowserbaseCertificates.create")(function* (upload) {
+			const { bytes, ...options } = upload;
+			const value = yield* api.input(Upload, options, "certificate-create");
+			const owned = new Uint8Array(bytes);
+			const raw = yield* client.upload("/v1/certificates", {
+				field: "file",
+				filename: value.filename ?? "certificate.pem",
+				mediaType: "application/x-pem-file",
+				bytes: owned
+			}, {
+				maxBytes: value.maxBytes ?? 65536,
+				...value.timeoutMillis === void 0 ? {} : { timeoutMillis: value.timeoutMillis }
+			}).pipe(Effect.mapError(api.fromClient("certificate-create")));
+			const created = yield* Schema.decodeUnknownEffect(ProviderCertificate)(raw).pipe(Effect.mapError(() => api.malformed("certificate-create", true)));
+			return yield* own("certificate-create", true)(created);
+		});
+		const list = api.request("GET", "/v1/certificates", Schema.Array(ProviderCertificate).check(Schema.isMaxLength(1024)), "certificate-list").pipe(Effect.flatMap(Effect.forEach(own("certificate-list", false))), Effect.withSpan("BrowserbaseCertificates.list"));
+		const retrieve = Effect.fn("BrowserbaseCertificates.retrieve")(function* (certificateId) {
+			const id = yield* api.input(Identifier, certificateId, "certificate-retrieve");
+			const value = yield* api.request("GET", `/v1/certificates/${api.segment(id)}`, ProviderCertificate, "certificate-retrieve");
+			if (value.id !== id) return yield* api.malformed("certificate-retrieve", false);
+			return yield* own("certificate-retrieve", false)(value);
+		});
+		const remove = Effect.fn("BrowserbaseCertificates.delete")(function* (certificateId) {
+			const id = yield* api.input(Identifier, certificateId, "certificate-delete");
+			yield* api.remove(`/v1/certificates/${api.segment(id)}`, "certificate-delete");
+		});
+		return BrowserbaseCertificates.of({
+			create,
+			list,
+			retrieve,
+			delete: remove
+		});
+	}));
+};
+//#endregion
+export { BrowserbaseCertificates, CertificateMetadata, Certificates_exports as t };
+
+//# sourceMappingURL=Certificates.mjs.map

package/dist/Certificates.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Certificates.mjs","names":[],"sources":["../src/Certificates.ts"],"sourcesContent":["import { Context, Effect, Layer, Schema } from \"effect\";\n\nimport { BrowserbaseClient } from \"./Client.ts\";\nimport { CertificateError } from \"./Errors.ts\";\nimport { resource } from \"./internal/http/Resource.ts\";\nimport { Identifier } from \"./References.ts\";\nimport { SafeFilename } from \"./Transfers.ts\";\n\nconst Timestamp = Schema.String.check(Schema.isMaxLength(64));\nconst MAX_CERTIFICATE_BYTES = 1024 * 1024;\n\n/** Select a certificate at launch with `provider.proxySettings.caCertificates: [certificateId]`. */\nexport class CertificateMetadata extends Schema.Class<CertificateMetadata>(\n  \"BrowserbaseCertificateMetadata\",\n)({\n  certificateId: Identifier,\n  projectId: Identifier,\n  createdAt: Timestamp,\n  updatedAt: Timestamp,\n}) {}\n\nexport interface CertificateUpload {\n  /** PEM or DER bytes of one CA certificate. */\n  readonly bytes: Uint8Array;\n  /** Portable basename sent with the part; defaults to `certificate.pem`. */\n  readonly filename?: string;\n  readonly maxBytes?: number;\n  readonly timeoutMillis?: number;\n}\n\nconst Upload = Schema.Struct({\n  filename: Schema.optionalKey(SafeFilename),\n  maxBytes: Schema.optionalKey(\n    Schema.Int.check(Schema.isBetween({ minimum: 1, maximum: MAX_CERTIFICATE_BYTES })),\n  ),\n  timeoutMillis: Schema.optionalKey(\n    Schema.Int.check(Schema.isBetween({ minimum: 1, maximum: 600_000 })),\n  ),\n});\n\nconst ProviderCertificate = Schema.Struct({\n  id: Identifier,\n  projectId: Identifier,\n  createdAt: Timestamp,\n  updatedAt: Timestamp,\n});\n\n/** Proxy CA certificates. Registration is one bounded multipart mutation, never retried. */\nexport class BrowserbaseCertificates extends Context.Service<\n  BrowserbaseCertificates,\n  {\n    readonly create: (\n      upload: CertificateUpload,\n    ) => Effect.Effect<CertificateMetadata, CertificateError>;\n    readonly list: Effect.Effect<ReadonlyArray<CertificateMetadata>, CertificateError>;\n    readonly retrieve: (\n      certificateId: string,\n    ) => Effect.Effect<CertificateMetadata, CertificateError>;\n    readonly delete: (certificateId: string) => Effect.Effect<void, CertificateError>;\n  }\n>()(\"effect-browserbase/Certificates\") {\n  static readonly layer: Layer.Layer<BrowserbaseCertificates, never, BrowserbaseClient> =\n    Layer.effect(\n      BrowserbaseCertificates,\n      Effect.gen(function* () {\n        const client = yield* BrowserbaseClient;\n        const api = resource<CertificateError>(client, (failure) => CertificateError.make(failure));\n\n        const own = (operation: CertificateError[\"operation\"], mutation: boolean) =>\n          Effect.fnUntraced(function* (value: typeof ProviderCertificate.Type) {\n            if (value.projectId !== client.projectId)\n              return yield* api.malformed(operation, mutation);\n\n            const { id, ...rest } = value;\n\n            return CertificateMetadata.make({ certificateId: id, ...rest });\n          });\n\n        const create = Effect.fn(\"BrowserbaseCertificates.create\")(function* (\n          upload: CertificateUpload,\n        ) {\n          const { bytes, ...options } = upload;\n          const value = yield* api.input(Upload, options, \"certificate-create\");\n          const owned = new Uint8Array(bytes);\n\n          const raw = yield* client\n            .upload(\n              \"/v1/certificates\",\n              {\n                field: \"file\",\n                filename: value.filename ?? \"certificate.pem\",\n                mediaType: \"application/x-pem-file\",\n                bytes: owned,\n              },\n              {\n                maxBytes: value.maxBytes ?? 64 * 1024,\n                ...(value.timeoutMillis === undefined\n                  ? {}\n                  : { timeoutMillis: value.timeoutMillis }),\n              },\n            )\n            .pipe(Effect.mapError(api.fromClient(\"certificate-create\")));\n\n          const created = yield* Schema.decodeUnknownEffect(ProviderCertificate)(raw).pipe(\n            Effect.mapError(() => api.malformed(\"certificate-create\", true)),\n          );\n\n          return yield* own(\"certificate-create\", true)(created);\n        });\n\n        const list = api\n          .request(\n            \"GET\",\n            \"/v1/certificates\",\n            Schema.Array(ProviderCertificate).check(Schema.isMaxLength(1024)),\n            \"certificate-list\",\n          )\n          .pipe(\n            Effect.flatMap(Effect.forEach(own(\"certificate-list\", false))),\n            Effect.withSpan(\"BrowserbaseCertificates.list\"),\n          );\n\n        const retrieve = Effect.fn(\"BrowserbaseCertificates.retrieve\")(function* (\n          certificateId: string,\n        ) {\n          const id = yield* api.input(Identifier, certificateId, \"certificate-retrieve\");\n\n          const value = yield* api.request(\n            \"GET\",\n            `/v1/certificates/${api.segment(id)}`,\n            ProviderCertificate,\n            \"certificate-retrieve\",\n          );\n\n          if (value.id !== id) return yield* api.malformed(\"certificate-retrieve\", false);\n\n          return yield* own(\"certificate-retrieve\", false)(value);\n        });\n\n        const remove = Effect.fn(\"BrowserbaseCertificates.delete\")(function* (\n          certificateId: string,\n        ) {\n          const id = yield* api.input(Identifier, certificateId, \"certificate-delete\");\n\n          yield* api.remove(`/v1/certificates/${api.segment(id)}`, \"certificate-delete\");\n        });\n\n        return BrowserbaseCertificates.of({ create, list, retrieve, delete: remove });\n      }),\n    );\n}\n"],"mappings":"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"}

package/dist/Cleanup-G2YpTCuU.d.mts

@@ -0,0 +1,24 @@
+import { o as SessionReference } from "./References-URDAtapt.mjs";
+import { Schema } from "effect";
+declare namespace Cleanup_d_exports {
+  export { CleanupIssue, CleanupResult };
+}
+declare const CleanupIssue_base: Schema.Class<CleanupIssue, Schema.Struct<{
+  readonly step: Schema.Literals<readonly ["fence", "capture", "initialization", "disconnect", "release", "status"]>;
+  readonly reason: Schema.Literals<readonly ["timeout", "failed", "interrupted"]>;
+}>, {}>;
+declare class CleanupIssue extends CleanupIssue_base {}
+declare const CleanupResult_base: Schema.Class<CleanupResult, Schema.Struct<{
+  readonly reference: typeof SessionReference;
+  readonly ownership: Schema.Literals<readonly ["owned", "borrowed"]>;
+  readonly releaseRequested: Schema.Boolean;
+  readonly remote: Schema.Literals<readonly ["confirmed", "pending", "unknown", "not-owned"]>;
+  readonly local: Schema.Literals<readonly ["closed", "failed", "not-connected", "pending"]>;
+  readonly observedStatus: Schema.optionalKey<Schema.Literals<readonly ["PENDING", "RUNNING", "ERROR", "TIMED_OUT", "COMPLETED"]>>;
+  readonly issues: Schema.$Array<typeof CleanupIssue>;
+}>, {}>;
+/** Local disconnection, release acknowledgement, and terminal observation are separate facts. */
+declare class CleanupResult extends CleanupResult_base {}
+//#endregion
+export { CleanupResult as n, Cleanup_d_exports as r, CleanupIssue as t };
+//# sourceMappingURL=Cleanup-G2YpTCuU.d.mts.map

package/dist/Cleanup.d.mts

@@ -0,0 +1,2 @@
+import { n as CleanupResult, t as CleanupIssue } from "./Cleanup-G2YpTCuU.mjs";
+export { CleanupIssue, CleanupResult };

package/dist/Cleanup.mjs

@@ -0,0 +1,48 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
+import { SessionReference } from "./References.mjs";
+import { SessionStatus } from "./SessionData.mjs";
+import { Schema } from "effect";
+//#region src/Cleanup.ts
+var Cleanup_exports = /* @__PURE__ */ __exportAll({
+	CleanupIssue: () => CleanupIssue,
+	CleanupResult: () => CleanupResult
+});
+var CleanupIssue = class extends Schema.Class("BrowserbaseCleanupIssue")({
+	step: Schema.Literals([
+		"fence",
+		"capture",
+		"initialization",
+		"disconnect",
+		"release",
+		"status"
+	]),
+	reason: Schema.Literals([
+		"timeout",
+		"failed",
+		"interrupted"
+	])
+}) {};
+/** Local disconnection, release acknowledgement, and terminal observation are separate facts. */
+var CleanupResult = class extends Schema.Class("BrowserbaseCleanupResult")({
+	reference: SessionReference,
+	ownership: Schema.Literals(["owned", "borrowed"]),
+	releaseRequested: Schema.Boolean,
+	remote: Schema.Literals([
+		"confirmed",
+		"pending",
+		"unknown",
+		"not-owned"
+	]),
+	local: Schema.Literals([
+		"closed",
+		"failed",
+		"not-connected",
+		"pending"
+	]),
+	observedStatus: Schema.optionalKey(SessionStatus),
+	issues: Schema.Array(CleanupIssue).check(Schema.isMaxLength(64))
+}) {};
+//#endregion
+export { CleanupIssue, CleanupResult, Cleanup_exports as t };
+
+//# sourceMappingURL=Cleanup.mjs.map

package/dist/Cleanup.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Cleanup.mjs","names":[],"sources":["../src/Cleanup.ts"],"sourcesContent":["import { Schema } from \"effect\";\n\nimport { SessionReference } from \"./References.ts\";\nimport { SessionStatus } from \"./SessionData.ts\";\n\nexport class CleanupIssue extends Schema.Class<CleanupIssue>(\"BrowserbaseCleanupIssue\")({\n  step: Schema.Literals([\"fence\", \"capture\", \"initialization\", \"disconnect\", \"release\", \"status\"]),\n  reason: Schema.Literals([\"timeout\", \"failed\", \"interrupted\"]),\n}) {}\n\n/** Local disconnection, release acknowledgement, and terminal observation are separate facts. */\nexport class CleanupResult extends Schema.Class<CleanupResult>(\"BrowserbaseCleanupResult\")({\n  reference: SessionReference,\n  ownership: Schema.Literals([\"owned\", \"borrowed\"]),\n  releaseRequested: Schema.Boolean,\n  remote: Schema.Literals([\"confirmed\", \"pending\", \"unknown\", \"not-owned\"]),\n  local: Schema.Literals([\"closed\", \"failed\", \"not-connected\", \"pending\"]),\n  observedStatus: Schema.optionalKey(SessionStatus),\n  issues: Schema.Array(CleanupIssue).check(Schema.isMaxLength(64)),\n}) {}\n"],"mappings":";;;;;;;;;AAKA,IAAa,eAAb,cAAkC,OAAO,MAAoB,yBAAyB,CAAC,CAAC;CACtF,MAAM,OAAO,SAAS;EAAC;EAAS;EAAW;EAAkB;EAAc;EAAW;CAAQ,CAAC;CAC/F,QAAQ,OAAO,SAAS;EAAC;EAAW;EAAU;CAAa,CAAC;AAC9D,CAAC,CAAC,CAAC,CAAC;;AAGJ,IAAa,gBAAb,cAAmC,OAAO,MAAqB,0BAA0B,CAAC,CAAC;CACzF,WAAW;CACX,WAAW,OAAO,SAAS,CAAC,SAAS,UAAU,CAAC;CAChD,kBAAkB,OAAO;CACzB,QAAQ,OAAO,SAAS;EAAC;EAAa;EAAW;EAAW;CAAW,CAAC;CACxE,OAAO,OAAO,SAAS;EAAC;EAAU;EAAU;EAAiB;CAAS,CAAC;CACvE,gBAAgB,OAAO,YAAY,aAAa;CAChD,QAAQ,OAAO,MAAM,YAAY,CAAC,CAAC,MAAM,OAAO,YAAY,EAAE,CAAC;AACjE,CAAC,CAAC,CAAC,CAAC"}

package/dist/Client-Ca0zSg1n.d.mts

@@ -0,0 +1,53 @@
+import { ClientError } from "./Errors.mjs";
+import { Config, Context, Effect, Layer, Redacted, Schema, Stream } from "effect";
+declare namespace Client_d_exports {
+  export { BrowserbaseClient, ClientMethod, ClientOptions, MultipartFile, UploadLimits };
+}
+/** Account authority only. Launch recipes and browser-operation policy do not belong here. */
+interface ClientOptions {
+  readonly projectId: string;
+  readonly apiKey: Redacted.Redacted<string>;
+  /** Exact HTTPS origins approved for credential-free media/artifact transfers. */
+  readonly artifactOrigins?: ReadonlyArray<string>;
+  readonly requestTimeoutMillis?: number;
+}
+type ClientMethod = "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
+/** One bounded in-memory file part. A filesystem path is never a transport input. */
+interface MultipartFile {
+  readonly field: string;
+  readonly filename: string;
+  readonly mediaType: string;
+  readonly bytes: Uint8Array;
+}
+/** Upload bounds are caller-owned; an omitted timeout keeps the 60-second default. */
+interface UploadLimits {
+  readonly maxBytes: number;
+  readonly timeoutMillis?: number;
+}
+declare const BrowserbaseClient_base: Context.ServiceClass<BrowserbaseClient, "effect-browserbase/Client", {
+  readonly projectId: string;
+  readonly json: (method: ClientMethod, path: string, body?: Schema.Json, outerDeadline?: number) => Effect.Effect<Schema.Json, ClientError>;
+  readonly noContent: (method: Exclude<ClientMethod, "GET">, path: string, body?: Schema.Json, outerDeadline?: number) => Effect.Effect<void, ClientError>;
+  /** One bounded multipart mutation. A lost reply stays unknown and is never retried. */
+  readonly upload: (path: string, part: MultipartFile, limits: UploadLimits, outerDeadline?: number) => Effect.Effect<Schema.Json, ClientError>;
+  readonly text: (path: string, maximum: number, types: ReadonlyArray<string>) => Effect.Effect<string, ClientError>;
+  readonly bytes: (path: string, maximum: number, types: ReadonlyArray<string>, timeoutMillis?: number, outerDeadline?: number) => Stream.Stream<Uint8Array, ClientError>;
+  readonly media: (url: Redacted.Redacted<string>, maximum: number, types: ReadonlyArray<string>, timeoutMillis?: number, outerDeadline?: number) => Stream.Stream<Uint8Array, ClientError>;
+  readonly validateMediaUrl: (value: string) => boolean;
+}>;
+/**
+ * One immutable Browserbase account and approved transport, shared by every resource Layer.
+ * Constructing the Layer performs no request and never loads the native browser peer.
+ */
+declare class BrowserbaseClient extends BrowserbaseClient_base {
+  static layer(options: ClientOptions): Layer.Layer<BrowserbaseClient, ClientError>;
+  /**
+   * Account authority from the application's `ConfigProvider` (the environment by default):
+   * `BROWSERBASE_PROJECT_ID` and a redacted `BROWSERBASE_API_KEY`. Transport options stay
+   * explicit. Configuration is read when the Layer is built, never at import.
+   */
+  static layerConfig(options?: Omit<ClientOptions, "projectId" | "apiKey">): Layer.Layer<BrowserbaseClient, ClientError | Config.ConfigError>;
+}
+//#endregion
+export { MultipartFile as a, Client_d_exports as i, ClientMethod as n, UploadLimits as o, ClientOptions as r, BrowserbaseClient as t };
+//# sourceMappingURL=Client-Ca0zSg1n.d.mts.map