@opencode/core 0.0.0-reserved → 2.0.0

package/dist/chunks/aisdk-native-qb9gpeer.js

@@ -0,0 +1,310 @@
+import {
+  Service79,
+  node84
+} from "./aisdk-native-11nvngjf.js";
+import {
+  __export
+} from "./aisdk-native-9rqn6x4v.js";
+
+// src/form.ts
+var exports_form = {};
+__export(exports_form, {
+  AlreadyExistsError: () => AlreadyExistsError2,
+  AlreadySettledError: () => AlreadySettledError2,
+  Answer: () => Answer2,
+  Event: () => Event19,
+  Field: () => Field2,
+  Fields: () => Fields2,
+  Form: () => exports_form,
+  ID: () => ID14,
+  Info: () => Info27,
+  InvalidAnswerError: () => InvalidAnswerError2,
+  InvalidFormError: () => InvalidFormError2,
+  NotFoundError: () => NotFoundError8,
+  Reply: () => Reply3,
+  Service: () => Service68,
+  State: () => State3,
+  When: () => When2,
+  layer: () => layer24,
+  node: () => node72,
+  validateAnswer: () => validateAnswer2,
+  validateFields: () => validateFields2
+});
+import { Form } from "@opencode/schema/form";
+import { Cache, Context, Deferred, Duration, Effect, Exit, Layer, Option, Schema } from "effect";
+import { makeLocationNode } from "@opencode/util/effect/app-node";
+import { Event as Event19 } from "@opencode/schema/form";
+var RETENTION = Duration.minutes(10);
+var ID14 = Form.ID;
+var Info27 = Form.Info;
+var Field2 = Form.Field;
+var Fields2 = Form.Fields;
+var When2 = Form.When;
+var State3 = Form.State;
+var Answer2 = Form.Answer;
+var Reply3 = Form.Reply;
+
+class NotFoundError8 extends Schema.TaggedError()("Form.NotFoundError", {
+  id: ID14
+}) {
+  get message() {
+    return `Form not found: ${this.id}`;
+  }
+}
+
+class AlreadySettledError2 extends Schema.TaggedError()("Form.AlreadySettledError", {
+  id: ID14
+}) {
+  get message() {
+    return `Form already settled: ${this.id}`;
+  }
+}
+
+class AlreadyExistsError2 extends Schema.TaggedError()("Form.AlreadyExistsError", {
+  id: ID14
+}) {
+  get message() {
+    return `Form already exists: ${this.id}`;
+  }
+}
+
+class InvalidAnswerError2 extends Schema.TaggedError()("Form.InvalidAnswerError", {
+  id: ID14,
+  message: Schema.String
+}) {
+}
+
+class InvalidFormError2 extends Schema.TaggedError()("Form.InvalidFormError", {
+  message: Schema.String
+}) {
+}
+
+class Service68 extends Context.Service()("@opencode/Form") {
+}
+var layer24 = Layer.effect(Service68, Effect.gen(function* () {
+  const bus = yield* Service79;
+  const forms = yield* Cache.makeWith(() => Effect.die(new Error("Form cache must be used via set/getSuccess, never get")), {
+    capacity: Number.MAX_SAFE_INTEGER,
+    timeToLive: (exit) => Exit.isSuccess(exit) && exit.value.state.status === "pending" ? Duration.infinity : RETENTION
+  });
+  const requireEntry = Effect.fn("Form.requireEntry")((id) => Cache.getSuccess(forms, id).pipe(Effect.flatMap((entry) => Effect.fromOption(entry, () => new NotFoundError8({ id })))));
+  const create = Effect.fn("Form.create")((input) => Effect.uninterruptible(Effect.gen(function* () {
+    const id = input.id ?? ID14.create();
+    const existing = yield* Cache.getSuccess(forms, id);
+    if (Option.isSome(existing))
+      return yield* new AlreadyExistsError2({ id });
+    const invalid = validateFields2(input.fields);
+    if (invalid)
+      return yield* new InvalidFormError2({ message: invalid });
+    const form = {
+      id,
+      sessionID: input.sessionID,
+      title: input.title,
+      ...input.metadata === undefined ? {} : { metadata: input.metadata },
+      fields: input.fields
+    };
+    const entry = {
+      form,
+      state: { status: "pending" },
+      deferred: yield* Deferred.make()
+    };
+    yield* Cache.set(forms, id, entry);
+    yield* bus.publish(Form.Event.Created, { form }).pipe(Effect.onError(() => Cache.invalidate(forms, id)));
+    return form;
+  })));
+  const ask = Effect.fn("Form.ask")((input) => Effect.uninterruptibleMask((restore) => Effect.gen(function* () {
+    const form = yield* create(input);
+    const entry = yield* requireEntry(form.id).pipe(Effect.orDie);
+    return yield* restore(Deferred.await(entry.deferred)).pipe(Effect.onInterrupt(() => Effect.ignore(cancel(form.id))));
+  })));
+  const get = Effect.fn("Form.get")(function* (id) {
+    return (yield* requireEntry(id)).form;
+  });
+  const list = Effect.fn("Form.list")(function* (input) {
+    const entries = yield* Cache.values(forms);
+    return Array.from(entries).filter((entry) => entry.state.status === "pending").filter((entry) => input?.sessionID === undefined || entry.form.sessionID === input.sessionID).map((entry) => entry.form);
+  });
+  const state = Effect.fn("Form.state")(function* (id) {
+    return (yield* requireEntry(id)).state;
+  });
+  const reply = Effect.fn("Form.reply")((input) => Effect.uninterruptible(Effect.gen(function* () {
+    const entry = yield* requireEntry(input.id);
+    if (entry.state.status !== "pending")
+      return yield* new AlreadySettledError2({ id: input.id });
+    const invalid = validateAnswer2(entry.form.fields, input.answer);
+    if (invalid)
+      return yield* new InvalidAnswerError2({ id: input.id, message: invalid });
+    const next = { status: "answered", answer: input.answer };
+    yield* bus.publish(Form.Event.Replied, {
+      id: input.id,
+      sessionID: entry.form.sessionID,
+      answer: input.answer
+    });
+    yield* Cache.set(forms, input.id, { ...entry, state: next });
+    yield* Deferred.succeed(entry.deferred, next);
+  })));
+  const cancel = Effect.fn("Form.cancel")((id) => Effect.uninterruptible(Effect.gen(function* () {
+    const entry = yield* requireEntry(id);
+    if (entry.state.status !== "pending")
+      return yield* new AlreadySettledError2({ id });
+    const next = { status: "cancelled" };
+    yield* bus.publish(Form.Event.Cancelled, { id, sessionID: entry.form.sessionID });
+    yield* Cache.set(forms, id, { ...entry, state: next });
+    yield* Deferred.succeed(entry.deferred, next);
+  })));
+  yield* Effect.addFinalizer(() => Cache.values(forms).pipe(Effect.flatMap((entries) => Effect.forEach(Array.from(entries).filter((entry) => entry.state.status === "pending"), (entry) => cancel(entry.form.id).pipe(Effect.ignore), { discard: true }))));
+  return Service68.of({ create, ask, get, list, state, reply, cancel });
+}));
+var node72 = makeLocationNode({ service: Service68, layer: layer24, deps: [node84] });
+function validateAnswer2(form, answer) {
+  const fields = new Map(form.map((field) => [field.key, field]));
+  for (const key of Object.keys(answer)) {
+    if (!fields.has(key))
+      return `Unknown form field: ${key}`;
+  }
+  for (const field of form) {
+    const value = answer[field.key];
+    if (field.type === "external") {
+      if (value !== true)
+        return `External form field must be acknowledged: ${field.key}`;
+      continue;
+    }
+    const active = isActive(field, answer);
+    if (value === undefined) {
+      if (field.required && active)
+        return `Missing required form field: ${field.key}`;
+      continue;
+    }
+    if (!active)
+      return `Form field is not active: ${field.key}`;
+    const invalid = validateField(field, value);
+    if (invalid)
+      return invalid;
+  }
+}
+function isActive(field, answer) {
+  if (!field.when)
+    return true;
+  return field.when.every((when) => matches(when, answer[when.key]));
+}
+function matches(when, value) {
+  if (value === undefined)
+    return false;
+  const hit = Array.isArray(value) ? value.some((item) => item === when.value) : value === when.value;
+  return when.op === "eq" ? hit : !hit;
+}
+function validateFields2(fields) {
+  if (fields.length === 0)
+    return "Form must have at least one field";
+  const earlier = new Map;
+  const keys = new Set;
+  for (const field of fields) {
+    if (keys.has(field.key))
+      return `Duplicate form field key: ${field.key}`;
+    keys.add(field.key);
+    if (field.type === "external")
+      continue;
+    for (const when of field.when ?? []) {
+      const target = earlier.get(when.key);
+      if (!target)
+        return `Form field condition must reference an earlier field: ${field.key} -> ${when.key}`;
+      const invalid = validateWhen(when, target);
+      if (invalid)
+        return `${invalid}: ${field.key} -> ${when.key}`;
+    }
+    earlier.set(field.key, field);
+  }
+}
+function validateWhen(when, target) {
+  if (target.type === "boolean") {
+    if (typeof when.value !== "boolean")
+      return "Form field condition value must be a boolean";
+    return;
+  }
+  if (target.type === "number" || target.type === "integer") {
+    if (typeof when.value !== "number")
+      return "Form field condition value must be a number";
+    return;
+  }
+  if (typeof when.value !== "string")
+    return "Form field condition value must be a string";
+  const closed = target.type === "multiselect" ? !target.custom : target.options !== undefined && !target.custom;
+  if (closed && !target.options?.some((option) => option.value === when.value)) {
+    return "Form field condition value must be one of the field's options";
+  }
+}
+function validateField(field, value) {
+  if (field.type === "string") {
+    if (typeof value !== "string")
+      return `Expected string for form field: ${field.key}`;
+    if (field.required && value.length === 0)
+      return `Missing required form field: ${field.key}`;
+    if (field.minLength !== undefined && value.length < field.minLength)
+      return `Form field is too short: ${field.key}`;
+    if (field.maxLength !== undefined && value.length > field.maxLength)
+      return `Form field is too long: ${field.key}`;
+    if (field.pattern !== undefined) {
+      try {
+        if (!new RegExp(field.pattern).test(value))
+          return `Form field does not match pattern: ${field.key}`;
+      } catch {
+        return `Form field has invalid pattern: ${field.key}`;
+      }
+    }
+    if (field.format === "email" && !/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value))
+      return `Expected email for form field: ${field.key}`;
+    if (field.format === "uri" && !URL.canParse(value))
+      return `Expected URI for form field: ${field.key}`;
+    if (field.format === "date" && !isDate(value))
+      return `Expected date for form field: ${field.key}`;
+    if (field.format === "date-time" && !isDateTime(value))
+      return `Expected date-time for form field: ${field.key}`;
+    if (field.options && !field.custom && !field.options.some((option) => option.value === value)) {
+      return `Invalid option for form field: ${field.key}`;
+    }
+    return;
+  }
+  if (field.type === "number" || field.type === "integer") {
+    if (typeof value !== "number" || !Number.isFinite(value))
+      return `Expected number for form field: ${field.key}`;
+    if (field.type === "integer" && !Number.isInteger(value))
+      return `Expected integer for form field: ${field.key}`;
+    if (field.minimum !== undefined && value < field.minimum)
+      return `Form field is too small: ${field.key}`;
+    if (field.maximum !== undefined && value > field.maximum)
+      return `Form field is too large: ${field.key}`;
+    return;
+  }
+  if (field.type === "boolean") {
+    if (typeof value !== "boolean")
+      return `Expected boolean for form field: ${field.key}`;
+    return;
+  }
+  if (field.type === "multiselect") {
+    if (!isStringArray(value))
+      return `Expected string array for form field: ${field.key}`;
+    if (field.required && value.length === 0)
+      return `Missing required form field: ${field.key}`;
+    if (field.minItems !== undefined && value.length < field.minItems)
+      return `Too few selections for form field: ${field.key}`;
+    if (field.maxItems !== undefined && value.length > field.maxItems)
+      return `Too many selections for form field: ${field.key}`;
+    if (!field.custom && value.some((item) => !field.options.some((option) => option.value === item))) {
+      return `Invalid option for form field: ${field.key}`;
+    }
+  }
+}
+function isStringArray(value) {
+  return Array.isArray(value) && value.every((item) => typeof item === "string");
+}
+function isDate(value) {
+  if (!/^\d{4}-\d{2}-\d{2}$/.test(value))
+    return false;
+  const date = new Date(`${value}T00:00:00.000Z`);
+  return !Number.isNaN(date.getTime()) && date.toISOString().slice(0, 10) === value;
+}
+function isDateTime(value) {
+  return !Number.isNaN(new Date(value).getTime());
+}
+
+export { ID14, Info27, Field2, Fields2, When2, State3, Answer2, Reply3, NotFoundError8, AlreadySettledError2, AlreadyExistsError2, InvalidAnswerError2, InvalidFormError2, Service68, layer24, node72, validateAnswer2, validateFields2, exports_form, Event19 };

package/dist/chunks/aisdk-native-qfa1cgps.js

@@ -0,0 +1,8 @@
+// src/database/schema.sql.ts
+import { integer } from "drizzle-orm/sqlite-core";
+var Timestamps2 = {
+  time_created: integer().notNull().$default(() => Date.now()),
+  time_updated: integer().notNull().$onUpdate(() => Date.now())
+};
+
+export { Timestamps2 };

package/dist/chunks/aisdk-native-qfw56etf.js

@@ -0,0 +1,202 @@
+import {
+  useragent2
+} from "./aisdk-native-cjg4xdhd.js";
+import {
+  OAuth3,
+  Service67
+} from "./aisdk-native-111hscse.js";
+import {
+  ID11,
+  MethodID2
+} from "./aisdk-native-tpbhnsa4.js";
+import {
+  ID18
+} from "./aisdk-native-33n3bzdy.js";
+
+// src/plugin/provider/xai.ts
+import { define } from "@opencode/plugin/effect/plugin";
+import { Clock, Effect, Option, Schema } from "effect";
+var clientID = "b1a00492-073a-47ea-816f-4c329264a828";
+var issuer = "https://auth.x.ai/oauth2";
+var deviceGrant = "urn:ietf:params:oauth:grant-type:device_code";
+var scope = "openid profile email offline_access grok-cli:access api:access";
+var pollingSafetyMargin = 3000;
+var browserMethodID = MethodID2.make("browser");
+var deviceMethodID = MethodID2.make("device");
+var providerID = ID18.make("xai");
+var Token = Schema.Struct({
+  access_token: Schema.String,
+  refresh_token: Schema.optional(Schema.String),
+  expires_in: Schema.optional(Schema.Number)
+});
+var Device = Schema.Struct({
+  device_code: Schema.String,
+  user_code: Schema.String,
+  verification_uri: Schema.String,
+  verification_uri_complete: Schema.optional(Schema.String),
+  expires_in: Schema.optional(Schema.Number),
+  interval: Schema.optional(Schema.Number)
+});
+var DeviceError = Schema.Struct({
+  error: Schema.optional(Schema.String),
+  error_description: Schema.optional(Schema.String)
+});
+var decodeDeviceError = Schema.decodeUnknownOption(Schema.fromJsonString(DeviceError));
+var device = (app) => ({
+  integrationID: ID11.make("xai"),
+  method: {
+    id: deviceMethodID,
+    type: "oauth",
+    label: "SuperGrok Subscription"
+  },
+  authorize: () => request(`${issuer}/device/code`, {
+    method: "POST",
+    headers: headers(app),
+    body: new URLSearchParams({ client_id: clientID, scope, referrer: "opencode" }).toString()
+  }, Device).pipe(Effect.flatMap((value) => Clock.currentTimeMillis.pipe(Effect.map((created) => {
+    const lifetime = positiveSeconds(value.expires_in, 0);
+    return {
+      mode: "auto",
+      url: value.verification_uri_complete ?? value.verification_uri,
+      instructions: `Open ${value.verification_uri} on any device and enter code: ${value.user_code}`,
+      ...lifetime ? { expiresAt: created + lifetime * 1000 } : {},
+      callback: poll(value, app).pipe(Effect.flatMap((tokens) => credential(deviceMethodID, tokens)))
+    };
+  })))),
+  refresh: (value) => refresh(deviceMethodID, OAuth3.make({ ...value, methodID: deviceMethodID }), app)
+});
+var XAIPlugin2 = define({
+  id: "opencode.provider.xai",
+  effect: Effect.fn(function* (ctx) {
+    const credentials = yield* Service67;
+    yield* Effect.forEach(yield* credentials.list(ID11.make("xai")), (credential) => {
+      if (credential.value.type !== "oauth" || credential.value.methodID !== browserMethodID)
+        return Effect.void;
+      return credentials.update(credential.id, {
+        value: OAuth3.make({ ...credential.value, methodID: deviceMethodID })
+      });
+    }, { discard: true });
+    yield* ctx.integration.transform((editor) => {
+      editor.update("xai", (integration) => {
+        integration.name = "xAI";
+      });
+      editor.method.update(device(ctx.app));
+      editor.method.update({ integrationID: "xai", method: { type: "key", label: "Manually enter API Key" } });
+    });
+    yield* ctx.catalog.transform((catalog) => {
+      const provider = catalog.provider.get(providerID);
+      if (!provider)
+        return;
+      for (const model of provider.models.values()) {
+        catalog.model.update(providerID, model.id, (draft) => {
+          draft.capabilities.responsesWebsockets = true;
+          draft.websocket = true;
+        });
+      }
+    });
+  })
+});
+function refresh(methodID, value, app) {
+  return request(`${issuer}/token`, {
+    method: "POST",
+    headers: headers(app),
+    body: new URLSearchParams({
+      grant_type: "refresh_token",
+      refresh_token: value.refresh,
+      client_id: clientID
+    }).toString()
+  }, Token).pipe(Effect.flatMap((tokens) => credential(methodID, tokens, value.refresh, value.metadata)));
+}
+function poll(device, app) {
+  return Effect.gen(function* () {
+    const started = yield* Clock.currentTimeMillis;
+    const expires = started + positiveSeconds(device.expires_in, 300) * 1000;
+    const loop = (interval) => Effect.gen(function* () {
+      if ((yield* Clock.currentTimeMillis) >= expires) {
+        return yield* Effect.fail(new Error("xAI device authorization timed out"));
+      }
+      const response = yield* send(`${issuer}/token`, {
+        method: "POST",
+        headers: headers(app),
+        body: new URLSearchParams({
+          grant_type: deviceGrant,
+          client_id: clientID,
+          device_code: device.device_code
+        }).toString()
+      });
+      if (response.ok)
+        return yield* decode(response, Token);
+      const error = yield* Effect.promise(() => response.text()).pipe(Effect.map((body) => Option.getOrUndefined(decodeDeviceError(body))), Effect.orElseSucceed(() => {
+        return;
+      }));
+      if (error?.error === "authorization_pending") {
+        return yield* Effect.sleep(interval + pollingSafetyMargin).pipe(Effect.andThen(loop(interval)));
+      }
+      if (error?.error === "slow_down") {
+        const next = interval + 5000;
+        return yield* Effect.sleep(next + pollingSafetyMargin).pipe(Effect.andThen(loop(next)));
+      }
+      if (error?.error === "access_denied" || error?.error === "authorization_denied") {
+        return yield* Effect.fail(new Error("xAI device authorization was denied"));
+      }
+      if (error?.error === "expired_token") {
+        return yield* Effect.fail(new Error("xAI device code expired - please re-run login"));
+      }
+      const detail = error?.error_description ?? error?.error;
+      return yield* Effect.fail(new Error(`xAI device token exchange failed (${response.status})${detail ? `: ${detail}` : ""}`));
+    });
+    return yield* loop(Math.max(positiveSeconds(device.interval, 5) * 1000, 1000));
+  });
+}
+function request(url, init, schema) {
+  return send(url, init).pipe(Effect.flatMap((response) => {
+    if (response.ok)
+      return decode(response, schema);
+    return Effect.promise(() => response.text()).pipe(Effect.flatMap((detail) => Effect.fail(new Error(`xAI request failed (${response.status})${detail ? `: ${detail}` : ""}`))));
+  }));
+}
+function send(url, init) {
+  return Effect.tryPromise({
+    try: (signal) => fetch(url, { ...init, signal }),
+    catch: (cause) => cause
+  });
+}
+function decode(response, schema) {
+  return Effect.promise(() => response.json()).pipe(Effect.map(Schema.decodeUnknownSync(schema)));
+}
+function credential(methodID, tokens, currentRefresh, metadata) {
+  const refresh = tokens.refresh_token ?? currentRefresh;
+  if (!refresh)
+    return Effect.fail(new Error("xAI token response is missing refresh_token"));
+  return Effect.succeed(OAuth3.make({
+    type: "oauth",
+    methodID,
+    refresh,
+    access: tokens.access_token,
+    expires: tokenExpiration(tokens),
+    metadata
+  }));
+}
+function tokenExpiration(tokens) {
+  if (tokens.expires_in)
+    return Date.now() + positiveSeconds(tokens.expires_in, 3600) * 1000;
+  const payload = tokens.access_token.split(".")[1];
+  if (!payload)
+    return Date.now() + 3600 * 1000;
+  const claims = Schema.decodeUnknownOption(Schema.fromJsonString(Schema.Struct({ exp: Schema.optional(Schema.Number) })))(Buffer.from(payload, "base64url").toString());
+  const expiration = Option.getOrUndefined(claims)?.exp;
+  return expiration ? expiration * 1000 : Date.now() + 3600 * 1000;
+}
+function headers(app) {
+  return {
+    "Content-Type": "application/x-www-form-urlencoded",
+    Accept: "application/json",
+    "User-Agent": useragent2(app)
+  };
+}
+function positiveSeconds(value, fallback) {
+  const seconds = Number(value);
+  return Number.isFinite(seconds) && seconds > 0 ? seconds : fallback;
+}
+
+export { XAIPlugin2 };

package/dist/chunks/aisdk-native-qh3awkqg.js

@@ -0,0 +1,74 @@
+import {
+  Service79
+} from "./aisdk-native-11nvngjf.js";
+import {
+  ID18
+} from "./aisdk-native-33n3bzdy.js";
+import {
+  ID13
+} from "./aisdk-native-jghsd1wz.js";
+import {
+  Event18
+} from "./aisdk-native-111hscse.js";
+import {
+  ID11
+} from "./aisdk-native-tpbhnsa4.js";
+import {
+  Service65
+} from "./aisdk-native-r4kwqy5f.js";
+import {
+  get3
+} from "./aisdk-native-yppnjwr8.js";
+
+// src/plugin/provider/modal.ts
+import { Effect, Semaphore, Stream } from "effect";
+import { define } from "@opencode/plugin/effect/plugin";
+var providerID = ID18.make("modal");
+var ModalPlugin2 = define({
+  id: "opencode.provider.modal",
+  effect: Effect.fn(function* (ctx) {
+    const catalog = yield* Service65;
+    const bus = yield* Service79;
+    const loading = Semaphore.makeUnsafe(1);
+    const loaded = {};
+    const load = Effect.fn("ModalPlugin.load")(function* () {
+      const connection = yield* ctx.integration.connection.active("modal");
+      const credential = connection ? yield* ctx.integration.connection.resolve(connection).pipe(Effect.orElseSucceed(() => {
+        return;
+      })) : undefined;
+      const apiKey = credential?.type === "key" ? credential.key : process.env.MODAL_PROXY_TOKEN;
+      const provider = yield* catalog.provider.get(providerID);
+      const baseURL = typeof provider?.settings?.baseURL === "string" ? provider.settings.baseURL : undefined;
+      if (!apiKey || !baseURL) {
+        loaded.baseURL = undefined;
+        loaded.models = undefined;
+        return;
+      }
+      loaded.baseURL = baseURL;
+      const existing = (yield* catalog.model.all()).filter((model) => model.providerID === providerID);
+      loaded.models = yield* Effect.tryPromise({
+        try: () => get3(baseURL, apiKey, existing),
+        catch: (cause) => cause
+      }).pipe(Effect.catch((cause) => Effect.logWarning("failed to sync Modal models", { cause }).pipe(Effect.as(undefined))));
+    });
+    yield* ctx.catalog.transform((evt) => {
+      const item = evt.provider.get(providerID);
+      if (!item)
+        return;
+      if (!loaded.models)
+        return;
+      for (const id of item.models.keys()) {
+        if (!loaded.models.has(ID13.make(id)))
+          evt.model.remove(item.provider.id, id);
+      }
+      for (const [id, model] of loaded.models) {
+        evt.model.update(item.provider.id, id, (draft) => Object.assign(draft, structuredClone(model)));
+      }
+    });
+    const refresh = () => loading.withPermit(load().pipe(Effect.andThen(ctx.catalog.reload())));
+    yield* bus.subscribe(Event18.Switched).pipe(Stream.filter((event) => event.data.integrationID === ID11.make("modal")), Stream.runForEach(refresh), Effect.forkScoped({ startImmediately: true }));
+    yield* refresh().pipe(Effect.forkScoped);
+  })
+});
+
+export { ModalPlugin2 };