@shwfed/config 1.1.5 → 2.0.1

package/dist/runtime/components/form/utils/commit-bus.js

@@ -0,0 +1,27 @@
+import { inject, provide } from "vue";
+const COMMIT_BUS_KEY = Symbol("shwfed-form-commit-bus");
+export function provideCommitBus() {
+  const commits = /* @__PURE__ */ new Set();
+  const bus = {
+    register(commit) {
+      commits.add(commit);
+      return () => {
+        commits.delete(commit);
+      };
+    },
+    flushAll() {
+      for (const commit of [...commits]) commit();
+    }
+  };
+  provide(COMMIT_BUS_KEY, bus);
+  return bus;
+}
+const NOOP_BUS = {
+  register: () => () => {
+  },
+  flushAll: () => {
+  }
+};
+export function useCommitBus() {
+  return inject(COMMIT_BUS_KEY, NOOP_BUS);
+}

package/dist/runtime/components/form/utils/common.d.ts

@@ -13,3 +13,30 @@ export declare const FIELD_ORIENTATION_OPTIONS: ReadonlyArray<{
 }>;
 export declare const FieldOrientationSchema: Schema.Literal<["vertical", "floating"]>;
 export declare const DEFAULT_FIELD_ORIENTATION: FieldOrientation;
+type ResultType = string | string[] | ((type: string) => boolean);
+/**
+ * The two ways a field's value can be derived from a CEL expression. They are
+ * mutually exclusive — a field carries at most one `derived` config, tagged
+ * with one of these modes.
+ *
+ * - `formula` — the field is read-only; its value is always the expression's
+ *   result, recomputed when dependencies change.
+ * - `prefill` — the field stays editable; the expression fills it only while
+ *   the user has not touched it. A manual edit (an explicit clear included)
+ *   takes over for good.
+ */
+export declare const DERIVED_MODES: readonly ["formula", "prefill"];
+export type DerivedMode = typeof DERIVED_MODES[number];
+export declare const DERIVED_MODE_LABELS: Readonly<Record<DerivedMode, string>>;
+/**
+ * Schema for a field's optional `derived` config — a `{ mode, expression }`
+ * tagged struct shared by every input field type. Mutual exclusion of the two
+ * modes is structural: one slot, one mode. `resultType` constrains the CEL
+ * expression to the field's own value type, exactly as the field's other
+ * expression schemas do.
+ */
+export declare function derivedField(configure: (env: Environment) => void, resultType: ResultType): Schema.optional<Schema.Struct<{
+    mode: Schema.Literal<["formula", "prefill"]>;
+    expression: Schema.Schema<string, string, never>;
+}>>;
+export {};

package/dist/runtime/components/form/utils/common.js

@@ -1,5 +1,6 @@
 import { Schema } from "effect";
 import { Expression } from "../../../share/expression.js";
+import { md } from "../../../share/markdown.js";
 export function commonFieldFields(configure) {
   const CelBool = Expression({ configure, resultType: "bool" });
   return {
@@ -24,3 +25,33 @@ export const FieldOrientationSchema = Schema.Literal(...FIELD_ORIENTATIONS).anno
   description: "\u6807\u7B7E\u4E0E\u8F93\u5165\u6846\u7684\u6392\u5217\u65B9\u5411"
 });
 export const DEFAULT_FIELD_ORIENTATION = "vertical";
+export const DERIVED_MODES = ["formula", "prefill"];
+export const DERIVED_MODE_LABELS = {
+  formula: "\u8BA1\u7B97\u503C",
+  prefill: "\u667A\u80FD\u586B\u5145"
+};
+export function derivedField(configure, resultType) {
+  return Schema.optional(
+    Schema.Struct({
+      mode: Schema.Literal(...DERIVED_MODES).annotations({
+        title: "\u6D3E\u751F\u65B9\u5F0F",
+        description: "`\u8BA1\u7B97\u503C` \u53EA\u8BFB\u3001\u59CB\u7EC8\u4EE5\u8868\u8FBE\u5F0F\u4E3A\u51C6\uFF1B`\u667A\u80FD\u586B\u5145` \u53EF\u7F16\u8F91\u3001\u7528\u6237\u4FEE\u6539\u540E\u4EE5\u7528\u6237\u4E3A\u51C6"
+      }),
+      expression: Expression({ configure, resultType }).annotations({
+        title: "\u8868\u8FBE\u5F0F",
+        description: "\u8FD4\u56DE\u8BE5\u5B57\u6BB5\u503C\u7684 CEL \u8868\u8FBE\u5F0F\uFF1B\u53EF\u8BBF\u95EE `form` \u5F53\u524D\u8868\u5355\u72B6\u6001"
+      })
+    }).annotations({
+      title: "\u6D3E\u751F\u503C",
+      description: md`
+        该字段值的**派生来源**，二选一：
+
+        - **计算值**：字段变为只读，其值始终由表达式计算得出，依赖字段提交时重算。
+
+        - **智能填充**：字段保持可编辑。用户未手动修改前由表达式持续计算并填入；一旦用户手动修改（含清空），即以用户输入为准，表达式不再覆盖。
+
+        两种方式都支持异步调用（如 \`http.get(...)\`）。
+      `
+    })
+  );
+}

package/dist/runtime/components/form/utils/derived.d.ts

@@ -0,0 +1,72 @@
+import { Effect } from 'effect';
+import type { Ref } from 'vue';
+import type { FieldValue } from '../schema.js';
+import type { FormStateBag } from './state.js';
+/**
+ * Structural equality over JSON-ish values (the shape a derived expression
+ * returns: primitives, arrays, plain objects, `Date`). It is load-bearing: a
+ * derived value writes its result back into form state, which re-triggers the
+ * expression; a shallow `Object.is` would see a fresh-but-equal array/object
+ * as a change and loop forever. With deep equality a settled expression's
+ * re-write is a no-op and cascades converge.
+ */
+export declare function deepEqual(a: unknown, b: unknown): boolean;
+export type DerivedQuiescence = {
+    /** Count of derived-value evaluations currently in flight, form-wide. */
+    inFlight: Ref<number>;
+    begin: () => void;
+    end: () => void;
+    /** Resolves once every derived value — including cascades — has settled. */
+    settled: () => Promise<void>;
+};
+/**
+ * Provide the form-wide derivation quiescence tracker. Called once at the
+ * top-level form host; nested list rows inherit it, so `settled()` waits on
+ * every derived value in the form — top-level and row-level alike.
+ */
+export declare function provideDerivedQuiescence(): DerivedQuiescence;
+/**
+ * Inject the form's quiescence tracker. Falls back to a standalone instance
+ * when mounted outside a form host.
+ */
+export declare function useDerivedQuiescence(): DerivedQuiescence;
+export type DerivedOptions = {
+    /**
+     * Every field of this form unit. Derived values run regardless of layout
+     * placement or `hidden` state — a hidden derived field still feeds
+     * submission.
+     */
+    fields: () => ReadonlyArray<FieldValue>;
+    /** Evaluate a derived expression against the host's CEL context. */
+    evaluate: (expression: string) => Effect.Effect<unknown, unknown>;
+    /**
+     * Derived values start only after this resolves — the top-level form passes
+     * its `initial` seed promise so first-paint uses the seed, then derivation
+     * takes over; list rows pass an already-resolved promise.
+     */
+    ready: Promise<void>;
+    /**
+     * The form unit's state bag — the top form's or a list row's. Passed
+     * explicitly rather than injected: `useDerived` runs in the very component
+     * that provides the bag, and a component cannot inject its own provide.
+     */
+    formState: FormStateBag;
+    /** The form-wide derivation quiescence tracker (provided at the top form). */
+    quiescence: DerivedQuiescence;
+};
+/**
+ * Maintains every derived field's value in this form unit. A field carrying a
+ * `derived` config is computed from a CEL expression and written back to its
+ * `binding`, recomputed whenever committed form state changes. Two modes:
+ *
+ * - `formula` — the field is read-only; its value is *always* the expression's
+ *   result.
+ * - `prefill` — the field stays editable; the expression only fills it while
+ *   the user has not touched the binding. Once `formState.isDirty(binding)` is
+ *   true the user has taken over and the expression no longer writes.
+ *
+ * Mounted by each form-unit host — the top form and every list row — so a row
+ * derived value evaluates `item`/writes row state, a top-level one evaluates
+ * `form`/writes form state, all sharing one quiescence tracker.
+ */
+export declare function useDerived(options: DerivedOptions): void;

package/dist/runtime/components/form/utils/derived.js

@@ -0,0 +1,116 @@
+import { Effect } from "effect";
+import { computed, inject, nextTick, onScopeDispose, provide, ref, watch } from "vue";
+export function deepEqual(a, b) {
+  if (Object.is(a, b)) return true;
+  if (a === null || b === null || typeof a !== "object" || typeof b !== "object") return false;
+  if (a instanceof Date || b instanceof Date) {
+    return a instanceof Date && b instanceof Date && a.getTime() === b.getTime();
+  }
+  if (Array.isArray(a) || Array.isArray(b)) {
+    if (!Array.isArray(a) || !Array.isArray(b) || a.length !== b.length) return false;
+    return a.every((v, i) => deepEqual(v, b[i]));
+  }
+  const ak = Object.keys(a);
+  const bk = Object.keys(b);
+  if (ak.length !== bk.length) return false;
+  return ak.every(
+    (k) => Object.prototype.hasOwnProperty.call(b, k) && deepEqual(a[k], b[k])
+  );
+}
+const QUIESCENCE_KEY = Symbol("shwfed-form-derived-quiescence");
+function createQuiescence() {
+  const inFlight = ref(0);
+  return {
+    inFlight,
+    begin: () => {
+      inFlight.value += 1;
+    },
+    end: () => {
+      inFlight.value -= 1;
+    },
+    async settled() {
+      for (; ; ) {
+        if (inFlight.value > 0) {
+          await new Promise((resolve) => {
+            const stop = watch(inFlight, (n) => {
+              if (n === 0) {
+                stop();
+                resolve();
+              }
+            });
+          });
+        }
+        await nextTick();
+        if (inFlight.value === 0) return;
+      }
+    }
+  };
+}
+export function provideDerivedQuiescence() {
+  const q = createQuiescence();
+  provide(QUIESCENCE_KEY, q);
+  return q;
+}
+export function useDerivedQuiescence() {
+  return inject(QUIESCENCE_KEY, null) ?? createQuiescence();
+}
+export function useDerived(options) {
+  const { state, getAt, setAtSilent, isDirty, markDirty } = options.formState;
+  const quiescence = options.quiescence;
+  const derivedFields = computed(
+    () => options.fields().flatMap((field) => {
+      const binding = field.binding;
+      const derived = field.derived;
+      if (typeof binding !== "string" || !derived || typeof derived !== "object") return [];
+      const mode = derived.mode;
+      const expression = derived.expression;
+      if (mode !== "formula" && mode !== "prefill" || typeof expression !== "string") return [];
+      return [{ binding, mode, expression }];
+    })
+  );
+  let generation = 0;
+  let started = false;
+  function evaluateField(field, gen) {
+    quiescence.begin();
+    Effect.runPromise(options.evaluate(field.expression)).then(
+      (result) => {
+        if (gen !== generation) return;
+        if (field.mode === "prefill" && isDirty(field.binding)) return;
+        if (!deepEqual(getAt(field.binding), result)) setAtSilent(field.binding, result);
+      },
+      () => {
+      }
+    ).finally(() => {
+      quiescence.end();
+    });
+  }
+  function runAll() {
+    const gen = generation += 1;
+    for (const field of derivedFields.value) evaluateField(field, gen);
+  }
+  watch([state, derivedFields], () => {
+    if (started) runAll();
+  });
+  function claimSeededValues() {
+    for (const field of derivedFields.value) {
+      if (field.mode === "prefill" && getAt(field.binding) !== void 0) {
+        markDirty(field.binding);
+      }
+    }
+  }
+  let disposed = false;
+  onScopeDispose(() => {
+    disposed = true;
+  });
+  options.ready.then(() => {
+    if (disposed) return;
+    started = true;
+    claimSeededValues();
+    runAll();
+  }, () => {
+    if (disposed) return;
+    started = true;
+    claimSeededValues();
+    runAll();
+  });
+}

package/dist/runtime/components/form/utils/field-value.d.ts

@@ -0,0 +1,35 @@
+import type { ComputedRef, WritableComputedRef } from 'vue';
+export type FieldValueController<T> = {
+    /**
+     * Live draft — bind to the input's `v-model`. Updates on every keystroke,
+     * but does NOT reach form state until `commit()` runs.
+     */
+    draft: WritableComputedRef<T>;
+    /** `true` while the draft holds an uncommitted user edit. */
+    dirty: ComputedRef<boolean>;
+    /** Flush the draft into form state. Wire to `@blur` / Enter / clear. */
+    commit: () => void;
+};
+export type FieldValueOptions<T> = {
+    /** Bound dot-prop path; `undefined` ⇒ uncontrolled (no form-state slot). */
+    binding: () => string | undefined;
+    /** Normalize a raw form-state value into the display-typed draft. */
+    fromState: (raw: unknown) => T;
+    /** Normalize the draft into the value written to form state. */
+    toState: (draft: T) => unknown;
+    /** Equality for dirty-detection; defaults to `Object.is`. */
+    equals?: (a: T, b: T) => boolean;
+};
+/**
+ * Splits a text-like field's value into a live `draft` and the committed
+ * form-state value. Keystrokes move the draft; `commit()` (wired to blur) is
+ * the only thing that writes form state — so every CEL expression and
+ * derived value reading `form` sees a stable per-commit cadence rather than
+ * per-keystroke churn.
+ *
+ * An external write to the committed value (initial seed, reset, parent
+ * v-model, a later derived write-back) reverse-syncs into the draft — unless
+ * the draft is dirty, so a mid-edit value the user has not committed is
+ * never clobbered.
+ */
+export declare function useFieldValue<T>(options: FieldValueOptions<T>): FieldValueController<T>;

package/dist/runtime/components/form/utils/field-value.js

@@ -0,0 +1,40 @@
+import { computed, onBeforeUnmount, ref, watch } from "vue";
+import { useCommitBus } from "./commit-bus.js";
+import { useFormState } from "./state.js";
+export function useFieldValue(options) {
+  const { getAt, setAt } = useFormState();
+  const equals = options.equals ?? Object.is;
+  const uncontrolled = ref(void 0);
+  const committed = computed(() => {
+    const path = options.binding();
+    const raw = path == null ? uncontrolled.value : getAt(path);
+    return options.fromState(raw);
+  });
+  const local = ref(committed.value);
+  const touched = ref(false);
+  const draft = computed({
+    get: () => local.value,
+    set: (next) => {
+      local.value = next;
+      touched.value = true;
+    }
+  });
+  function commit() {
+    if (!touched.value) return;
+    touched.value = false;
+    if (equals(local.value, committed.value)) return;
+    const path = options.binding();
+    const next = options.toState(local.value);
+    if (path == null) uncontrolled.value = next;
+    else setAt(path, next);
+  }
+  watch(committed, (next) => {
+    if (!touched.value) local.value = next;
+  });
+  const unregister = useCommitBus().register(commit);
+  onBeforeUnmount(() => {
+    unregister();
+    commit();
+  });
+  return { draft, dirty: computed(() => touched.value), commit };
+}

package/dist/runtime/components/form/utils/history.d.ts

@@ -0,0 +1,36 @@
+import type { Ref } from 'vue';
+import type { DerivedQuiescence } from './derived.js';
+import type { FormState } from './state.js';
+/**
+ * Deep clone over the form-state value space — primitives, `null`, arrays,
+ * plain objects, and `Date` (constructor preserved, so a `Date` subclass
+ * stays an instance of itself). `File`/`Blob` are immutable and shared by
+ * reference rather than copied.
+ *
+ * Used to snapshot form state into the undo history: `setAt` mutates nested
+ * objects in place, so a stored snapshot must be a structural copy or a
+ * later edit would reach back and corrupt history.
+ */
+export declare function deepClone<T>(value: T): T;
+export type FormHistory = {
+    undo: () => void;
+    redo: () => void;
+    canUndo: Ref<boolean>;
+    canRedo: Ref<boolean>;
+};
+/**
+ * Whole-form undo/redo. One snapshot is recorded per user-initiated change —
+ * a field commit plus the derivation cascade it triggers — taken once that
+ * cascade settles, so an undo step always lands on a coherent derived state.
+ *
+ * `useManualRefHistory` is deliberate over `useRefHistory`: snapshots are
+ * driven by commit boundaries, not by every `state` mutation (which would
+ * record per-keystroke and per-derivation-write churn). It tracks a private
+ * `{ state, dirty }` composite ref; undo/redo restore both back into the
+ * live `state` / `dirty` refs.
+ */
+export declare function useFormHistory(state: Ref<FormState>, options: {
+    quiescence: DerivedQuiescence;
+    seeded: Promise<void>;
+    dirty: Ref<Set<string>>;
+}): FormHistory;

package/dist/runtime/components/form/utils/history.js

@@ -0,0 +1,74 @@
+import { useManualRefHistory } from "@vueuse/core";
+import { nextTick, ref, watch } from "vue";
+import { deepEqual } from "./derived.js";
+export function deepClone(value) {
+  if (value === null || typeof value !== "object") return value;
+  if (value instanceof Date) {
+    return new value.constructor(value.getTime());
+  }
+  if (typeof File !== "undefined" && value instanceof File) return value;
+  if (typeof Blob !== "undefined" && value instanceof Blob) return value;
+  if (Array.isArray(value)) return value.map((v) => deepClone(v));
+  const out = {};
+  for (const key of Object.keys(value)) {
+    out[key] = deepClone(value[key]);
+  }
+  return out;
+}
+function sameDirty(a, b) {
+  return a.length === b.length && a.every((p) => b.includes(p));
+}
+export function useFormHistory(state, options) {
+  const { dirty } = options;
+  function capture() {
+    return { state: state.value, dirty: [...dirty.value] };
+  }
+  function clone(s) {
+    return { state: deepClone(s.state), dirty: [...s.dirty] };
+  }
+  const tracked = ref(capture());
+  const history = useManualRefHistory(tracked, {
+    dump: clone,
+    parse: clone,
+    capacity: 50
+  });
+  let navigating = false;
+  let recording = false;
+  let snapshotPending = false;
+  async function scheduleSnapshot() {
+    if (snapshotPending) return;
+    snapshotPending = true;
+    await options.quiescence.settled();
+    snapshotPending = false;
+    if (!recording || navigating) return;
+    tracked.value = capture();
+    const last = history.last.value.snapshot;
+    if (!deepEqual(tracked.value.state, last.state) || !sameDirty(tracked.value.dirty, last.dirty)) {
+      history.commit();
+    }
+  }
+  watch(state, () => {
+    if (recording && !navigating) void scheduleSnapshot();
+  });
+  options.seeded.then(() => options.quiescence.settled()).then(() => {
+    tracked.value = capture();
+    history.commit();
+    history.clear();
+    recording = true;
+  });
+  function navigate(run) {
+    navigating = true;
+    run();
+    state.value = deepClone(tracked.value.state);
+    dirty.value = new Set(tracked.value.dirty);
+    void nextTick(() => {
+      navigating = false;
+    });
+  }
+  return {
+    undo: () => navigate(() => history.undo()),
+    redo: () => navigate(() => history.redo()),
+    canUndo: history.canUndo,
+    canRedo: history.canRedo
+  };
+}

package/dist/runtime/components/form/utils/readonly.d.ts

@@ -0,0 +1,8 @@
+import type { Ref } from 'vue';
+/** Provide the form-wide readonly flag. Called once at the top-level form. */
+export declare function provideFormReadonly(readonly: Ref<boolean>): void;
+/**
+ * Inject the form-wide readonly flag. Falls back to a never-readonly ref when
+ * a field is mounted outside a form host.
+ */
+export declare function useFormReadonly(): Ref<boolean>;

package/dist/runtime/components/form/utils/readonly.js

@@ -0,0 +1,9 @@
+import { inject, provide, ref } from "vue";
+const FORM_READONLY_KEY = Symbol("shwfed-form-readonly");
+const NEVER_READONLY = ref(false);
+export function provideFormReadonly(readonly) {
+  provide(FORM_READONLY_KEY, readonly);
+}
+export function useFormReadonly() {
+  return inject(FORM_READONLY_KEY, NEVER_READONLY);
+}

package/dist/runtime/components/form/utils/state.d.ts

@@ -3,8 +3,34 @@ export type FormState = Record<string, unknown>;
 export type FormStateBag = {
     state: Ref<FormState>;
     getAt: (path: string) => unknown;
+    /**
+     * Write a value at `path` on behalf of a **user interaction**. Besides
+     * writing, it marks the binding dirty — see `dirty`. Every field runtime
+     * writes its bound value through this.
+     */
     setAt: (path: string, value: unknown) => void;
-    delAt: (path: string) => void;
+    /**
+     * Write a value at `path` **without** touching the dirty set — a system
+     * write. Used by the derived-value engine (`useDerived`) and by the remote
+     * combobox's stale-selection clear: neither is a user intent, so neither
+     * may flip a `prefill` binding to "user-owned".
+     */
+    setAtSilent: (path: string, value: unknown) => void;
+    /**
+     * Bindings the user has touched. A `prefill`-mode derived value stops
+     * filling a binding the moment it appears here — the user has taken over.
+     * `setAt` adds to it (an explicit clear counts as a touch too); it is never
+     * cleared during normal operation. Only undo/redo rolls it back, by
+     * snapshotting it alongside `state` — see `history.ts`.
+     */
+    dirty: Ref<Set<string>>;
+    isDirty: (path: string) => boolean;
+    /**
+     * Mark a binding dirty without writing a value — used by `useDerived` at
+     * startup to claim every `initial`-seeded / loaded value, so a `prefill`
+     * expression will not overwrite it.
+     */
+    markDirty: (path: string) => void;
 };
 export declare const FORM_STATE_KEY: InjectionKey<FormStateBag>;
 export declare function provideFormState(state: Ref<FormState>): FormStateBag;

package/dist/runtime/components/form/utils/state.js

@@ -1,18 +1,26 @@
-import { deleteProperty, getProperty, setProperty } from "dot-prop";
-import { inject, provide } from "vue";
+import { getProperty, setProperty } from "dot-prop";
+import { inject, provide, ref } from "vue";
 export const FORM_STATE_KEY = Symbol("shwfed-form-state");
 export function provideFormState(state) {
+  const dirty = ref(/* @__PURE__ */ new Set());
+  function write(path, value) {
+    setProperty(state.value, path, value === void 0 ? null : value);
+    state.value = { ...state.value };
+  }
+  function markDirty(path) {
+    if (!dirty.value.has(path)) dirty.value = new Set(dirty.value).add(path);
+  }
   const bag = {
     state,
     getAt: (path) => getProperty(state.value, path),
     setAt: (path, value) => {
-      setProperty(state.value, path, value);
-      state.value = { ...state.value };
+      write(path, value);
+      markDirty(path);
     },
-    delAt: (path) => {
-      deleteProperty(state.value, path);
-      state.value = { ...state.value };
-    }
+    setAtSilent: write,
+    dirty,
+    isDirty: (path) => dirty.value.has(path),
+    markDirty
   };
   provide(FORM_STATE_KEY, bag);
   return bag;

package/dist/runtime/components/table/ai/columns-button.vue

@@ -1,5 +1,5 @@
 <script setup>
-import { useNuxtApp } from "#app";
+import { celCheck as $celCheck } from "../../../utils/cel";
 import { Icon } from "@iconify/vue";
 import { Either, ParseResult, Schema } from "effect";
 import { computed, ref } from "vue";
@@ -10,8 +10,8 @@ import { InputGroupButton } from "../../ui/input-group";
 import { Markdown } from "../../ui/markdown";
 import { Textarea } from "../../ui/textarea";
 import { Tooltip, TooltipContent, TooltipTrigger } from "../../ui/tooltip";
-import { composeCelPrompt } from "../../../plugins/ai/cel-prompt";
-import { StructuredOutputDecodeError } from "../../../plugins/ai";
+import { composeCelPrompt } from "../../../utils/ai/cel-prompt";
+import { StructuredOutputDecodeError, ai as $ai } from "../../../utils/ai";
 import { COLUMNS, findColumn } from "../utils/resolve";
 import TASK from "./columns-task.md?raw";
 defineOptions({ name: "ShwfedTableAiColumnsButton" });
@@ -20,7 +20,6 @@ const props = defineProps({
   columns: { type: Array, required: false }
 });
 const emit = defineEmits(["apply"]);
-const { $ai, $celCheck } = useNuxtApp();
 const LocaleEntry = Schema.Struct({
   locale: Schema.String,
   message: Schema.String

package/dist/runtime/components/table/ai/data-source-button.vue

@@ -1,5 +1,5 @@
 <script setup>
-import { useNuxtApp } from "#app";
+import { celCheck as $celCheck } from "../../../utils/cel";
 import { Icon } from "@iconify/vue";
 import { Either, Schema } from "effect";
 import { computed, ref } from "vue";
@@ -9,8 +9,8 @@ import { Button } from "../../ui/button";
 import { Markdown } from "../../ui/markdown";
 import { Textarea } from "../../ui/textarea";
 import { Tooltip, TooltipContent, TooltipTrigger } from "../../ui/tooltip";
-import { composeCelPrompt } from "../../../plugins/ai/cel-prompt";
-import { StructuredOutputDecodeError } from "../../../plugins/ai";
+import { composeCelPrompt } from "../../../utils/ai/cel-prompt";
+import { StructuredOutputDecodeError, ai as $ai } from "../../../utils/ai";
 import TASK from "./data-source-task.md?raw";
 defineOptions({ name: "ShwfedTableAiDataSourceButton" });
 const props = defineProps({
@@ -18,7 +18,6 @@ const props = defineProps({
   columns: { type: Array, required: false }
 });
 const emit = defineEmits(["apply"]);
-const { $ai, $celCheck } = useNuxtApp();
 const DataSourceDraft = Schema.Struct({
   request: Schema.optional(Schema.String).annotations({
     description: 'CEL expression returning an HttpRequest (e.g. http.get("/api/users").query("page", pageIndex + 1)). Omit if the data is static or comes from an outer context.'

package/dist/runtime/components/table/columns/2026-04-14/com.shwfed.table.column.icon/runtime.vue

@@ -2,15 +2,14 @@
 import { computed } from "vue";
 import { Icon } from "@iconify/vue";
 import { Effect } from "effect";
-import { useNuxtApp } from "#app";
-import { celBindings, injectCELContext } from "../../../../../plugins/cel/context";
+import { cel as $cel } from "../../../../../utils/cel";
+import { celBindings, injectCELContext } from "../../../../../utils/cel-context";
 import { JUSTIFY_CLASS } from "../../../utils/runtime";
 defineOptions({ name: "ShwfedTableIconRendererRuntime" });
 const props = defineProps({
   column: { type: null, required: true },
   ctx: { type: Object, required: true }
 });
-const { $cel } = useNuxtApp();
 const celContext = injectCELContext();
 const iconName = computed(() => {
   const v = props.ctx.cell.getValue();

package/dist/runtime/components/table/columns/2026-04-14/com.shwfed.table.column.markdown/runtime.vue

@@ -2,19 +2,18 @@
 import { computed } from "vue";
 import { Icon } from "@iconify/vue";
 import { Effect } from "effect";
-import { useNuxtApp } from "#app";
+import { cel as $cel } from "../../../../../utils/cel";
 import { useI18n } from "vue-i18n";
 import { getLocalizedText } from "../../../../../share/locale";
 import { Button } from "../../../../ui/button";
 import { Markdown } from "../../../../ui/markdown";
 import { JUSTIFY_CLASS, interpolateMarkdown } from "../../../utils/runtime";
-import { celBindings, injectCELContext } from "../../../../../plugins/cel/context";
+import { celBindings, injectCELContext } from "../../../../../utils/cel-context";
 defineOptions({ name: "ShwfedTableMarkdownRendererRuntime" });
 const props = defineProps({
   column: { type: null, required: true },
   ctx: { type: Object, required: true }
 });
-const { $cel } = useNuxtApp();
 const { locale } = useI18n();
 const celContext = injectCELContext();
 const rendered = computed(() => {