@boboddy/sdk 0.1.6-alpha → 0.1.7-alpha

package/dist/definitions/advancement-policies/define-advancement-policy.d.ts

@@ -1,3 +1,50 @@
+/** Aggregation types supported by the runtime for computed signals. */
+export type PipelineStepComputedSignalType = "average" | "weighted_average" | "sum" | "min" | "max" | "count" | "boolean_any" | "boolean_all";
+type Join<T extends readonly string[], D extends string> = T extends readonly [
+    infer Head extends string,
+    ...infer Rest extends readonly string[]
+] ? Rest extends readonly [] ? Head : `${Head}${D}${Join<Rest, D>}` : "";
+/**
+ * An inline computed-signal token returned by `Computed.X(...)`. Carries the
+ * derived `key` (e.g. `"sum_success"`), the aggregation `type`, and the input
+ * signal keys it aggregates over. At serialization time, every inline token
+ * embedded in a rule's signal position is extracted into the step's
+ * `computedSignalDefinitions` and replaced by its bare key string.
+ *
+ * - `TKey`             — the auto-derived key (literal template).
+ * - `TInputSignalKeys` — the union of input signal keys; constrained to the
+ *                        step's signals via `Rule.signal` / `Rule.when` typing.
+ */
+export type InlineComputedSignal<TKey extends string = string, TInputSignalKeys extends string = string> = {
+    readonly _tag: "computed_signal";
+    readonly key: TKey;
+    readonly type: PipelineStepComputedSignalType;
+    readonly inputSignalKeys: ReadonlyArray<TInputSignalKeys>;
+    readonly configJson: Record<string, unknown> | null;
+    readonly availableWhenResultStatusIn: readonly string[] | null;
+};
+type ComputedOptions = {
+    configJson?: Record<string, unknown> | null;
+    availableWhenResultStatusIn?: readonly string[] | null;
+};
+/**
+ * Factories for inline computed signals. Each call returns a token whose `key`
+ * is auto-derived as `${type}_${inputSignalKeys.join("_")}`.
+ *
+ * @example
+ * Rule.when(Computed.sum(["success"]), "greaterThan", 1, "continue")
+ * Rule.signal(Computed.average(["score"]), "greaterThanInclusive", 80)
+ */
+export declare const Computed: {
+    readonly average: <const TInputs extends readonly [string, string, ...string[]]>(inputSignalKeys: TInputs, options?: ComputedOptions) => InlineComputedSignal<`average_${Join<TInputs, "_">}`, TInputs[number]>;
+    readonly weightedAverage: <const TInputs extends readonly [string, string, ...string[]]>(inputSignalKeys: TInputs, options?: ComputedOptions) => InlineComputedSignal<`weighted_average_${Join<TInputs, "_">}`, TInputs[number]>;
+    readonly sum: <const TInputs extends readonly [string, string, ...string[]]>(inputSignalKeys: TInputs, options?: ComputedOptions) => InlineComputedSignal<`sum_${Join<TInputs, "_">}`, TInputs[number]>;
+    readonly min: <const TInputs extends readonly [string, string, ...string[]]>(inputSignalKeys: TInputs, options?: ComputedOptions) => InlineComputedSignal<`min_${Join<TInputs, "_">}`, TInputs[number]>;
+    readonly max: <const TInputs extends readonly [string, string, ...string[]]>(inputSignalKeys: TInputs, options?: ComputedOptions) => InlineComputedSignal<`max_${Join<TInputs, "_">}`, TInputs[number]>;
+    readonly count: <const TInputs extends readonly [string, string, ...string[]]>(inputSignalKeys: TInputs, options?: ComputedOptions) => InlineComputedSignal<`count_${Join<TInputs, "_">}`, TInputs[number]>;
+    readonly booleanAny: <const TInputs extends readonly [string, string, ...string[]]>(inputSignalKeys: TInputs, options?: ComputedOptions) => InlineComputedSignal<`boolean_any_${Join<TInputs, "_">}`, TInputs[number]>;
+    readonly booleanAll: <const TInputs extends readonly [string, string, ...string[]]>(inputSignalKeys: TInputs, options?: ComputedOptions) => InlineComputedSignal<`boolean_all_${Join<TInputs, "_">}`, TInputs[number]>;
+};
 /**
  * Comparison operators supported by json-rules-engine.
  * These map directly to the operator names the runtime evaluates against signal values.
@@ -26,11 +73,14 @@ export type AdvancementOutcome = AdvancementEventType | {
  * by `Rule.when()`.
  *
  * `TSignalKeys` is constrained to the declaring step's signal keys, so the
- * `signal` field is validated at compile time.
+ * `signal` field is validated at compile time. `signal` may be either a step
+ * signal key (string) or an inline `Computed.X(...)` token — at serialization
+ * time, inline tokens are hoisted into `computedSignalDefinitions` and replaced
+ * by their bare key string.
  */
 export type SignalCondition<TSignalKeys extends string = string> = {
     readonly _tag: "signal";
-    signal: TSignalKeys;
+    signal: TSignalKeys | InlineComputedSignal<string, TSignalKeys>;
     operator: ConditionOperator;
     value: unknown;
 };
@@ -80,7 +130,7 @@ export type Rule<TSignalKeys extends string = string> = {
  *   Rule.signal("flagged", "equal", false),
  * ], "continue")
  */
-declare function signal<TSignalKeys extends string>(signal: TSignalKeys, operator: ConditionOperator, value: unknown): SignalCondition<TSignalKeys>;
+declare function signal<TSignalKeys extends string>(signal: TSignalKeys | InlineComputedSignal<string, TSignalKeys>, operator: ConditionOperator, value: unknown): SignalCondition<TSignalKeys>;
 /**
  * When called with only `conditions`: returns a nested `AllCondition` group
  * for use inside another `Rule.all()` or `Rule.any()`.
@@ -136,7 +186,7 @@ declare function any<TSignalKeys extends string>(conditions: RuleCondition<TSign
  * Rule.when("passed", "equal", true, "continue")
  * Rule.when("score", "greaterThanInclusive", 80, { outcome: "continue", outcomeJson: { via: "score" } })
  */
-declare function when<TSignalKeys extends string>(signal: TSignalKeys, operator: ConditionOperator, value: unknown, outcome: AdvancementOutcome): Rule<TSignalKeys>;
+declare function when<TSignalKeys extends string>(signal: TSignalKeys | InlineComputedSignal<string, TSignalKeys>, operator: ConditionOperator, value: unknown, outcome: AdvancementOutcome): Rule<TSignalKeys>;
 /**
  * All factories for building advancement rules.
  *
@@ -215,4 +265,19 @@ export type SerializedAdvancementPolicy = {
     allowedEventTypes: AdvancementEventType[];
 };
 export declare function serializeAdvancementPolicy(policy: AdvancementPolicy | undefined): SerializedAdvancementPolicy;
+/** Wire-format computed signal definition emitted on the pipeline step. */
+export type SerializedComputedSignalDefinition = {
+    key: string;
+    type: PipelineStepComputedSignalType;
+    inputSignalKeys: string[];
+    configJson: Record<string, unknown> | null;
+    availableWhenResultStatusIn: string[] | null;
+};
+/**
+ * Walks the rules tree, extracts every inline `Computed.X(...)` token embedded
+ * in a `SignalCondition.signal` position, dedupes by key, and returns the
+ * resulting computed-signal definitions. Two tokens with the same key but
+ * differing definitions are a programming error and throw.
+ */
+export declare function extractInlineComputedSignals(policy: AdvancementPolicy | undefined): SerializedComputedSignalDefinition[];
 export {};

package/dist/definitions/advancement-policies/index.js

@@ -14,6 +14,27 @@ var __export = (target, all) => {
 };
 
 // src/definitions/advancement-policies/define-advancement-policy.ts
+function makeComputed(type, inputSignalKeys, options) {
+  const key = [type, ...inputSignalKeys].join("_");
+  return {
+    _tag: "computed_signal",
+    key,
+    type,
+    inputSignalKeys,
+    configJson: options?.configJson ?? null,
+    availableWhenResultStatusIn: options?.availableWhenResultStatusIn ?? null
+  };
+}
+var Computed = {
+  average: (inputSignalKeys, options) => makeComputed("average", inputSignalKeys, options),
+  weightedAverage: (inputSignalKeys, options) => makeComputed("weighted_average", inputSignalKeys, options),
+  sum: (inputSignalKeys, options) => makeComputed("sum", inputSignalKeys, options),
+  min: (inputSignalKeys, options) => makeComputed("min", inputSignalKeys, options),
+  max: (inputSignalKeys, options) => makeComputed("max", inputSignalKeys, options),
+  count: (inputSignalKeys, options) => makeComputed("count", inputSignalKeys, options),
+  booleanAny: (inputSignalKeys, options) => makeComputed("boolean_any", inputSignalKeys, options),
+  booleanAll: (inputSignalKeys, options) => makeComputed("boolean_all", inputSignalKeys, options)
+};
 function signal(signal2, operator, value) {
   return { _tag: "signal", signal: signal2, operator, value };
 }
@@ -47,7 +68,7 @@ function resolveOutcome(outcome) {
 function serializeCondition(condition) {
   if (condition._tag === "signal") {
     return {
-      fact: condition.signal,
+      fact: typeof condition.signal === "string" ? condition.signal : condition.signal.key,
       operator: condition.operator,
       value: condition.value
     };
@@ -89,7 +110,49 @@ function serializeAdvancementPolicy(policy) {
     allowedEventTypes: [...outcomeSet]
   };
 }
+function visitSignalConditions(conditions, visit) {
+  for (const c of conditions) {
+    if (c._tag === "signal") {
+      visit(c);
+    } else {
+      visitSignalConditions(c.conditions, visit);
+    }
+  }
+}
+function isSameComputedDefinition(a, b) {
+  return a.type === b.type && a.inputSignalKeys.length === b.inputSignalKeys.length && a.inputSignalKeys.every((k, i) => k === b.inputSignalKeys[i]) && JSON.stringify(a.configJson) === JSON.stringify(b.configJson) && JSON.stringify(a.availableWhenResultStatusIn) === JSON.stringify(b.availableWhenResultStatusIn);
+}
+function extractInlineComputedSignals(policy) {
+  if (!policy?.rules)
+    return [];
+  const byKey = new Map;
+  for (const rule of policy.rules) {
+    visitSignalConditions(rule.conditions, (cond) => {
+      if (typeof cond.signal === "string")
+        return;
+      const inline = cond.signal;
+      const def = {
+        key: inline.key,
+        type: inline.type,
+        inputSignalKeys: [...inline.inputSignalKeys],
+        configJson: inline.configJson,
+        availableWhenResultStatusIn: inline.availableWhenResultStatusIn ? [...inline.availableWhenResultStatusIn] : null
+      };
+      const existing = byKey.get(def.key);
+      if (existing) {
+        if (!isSameComputedDefinition(existing, def)) {
+          throw new Error(`Conflicting inline computed signal definitions for key "${def.key}"`);
+        }
+        return;
+      }
+      byKey.set(def.key, def);
+    });
+  }
+  return [...byKey.values()];
+}
 export {
   serializeAdvancementPolicy,
-  Rule
+  extractInlineComputedSignals,
+  Rule,
+  Computed
 };

package/dist/definitions/pipelines/define-pipeline.d.ts

@@ -1,8 +1,8 @@
 import type { ZodType } from "zod";
 import type { DotPaths, TypedStepDefinitionSpec } from "../steps/define-step";
-import { type AdvancementPolicy, type SerializedAdvancementPolicy } from "../advancement-policies/define-advancement-policy";
-export type { AdvancementPolicy } from "../advancement-policies/define-advancement-policy";
-export { Rule } from "../advancement-policies/define-advancement-policy";
+import { type AdvancementPolicy, type SerializedAdvancementPolicy, type SerializedComputedSignalDefinition } from "../advancement-policies/define-advancement-policy";
+export type { AdvancementPolicy, PipelineStepComputedSignalType, } from "../advancement-policies/define-advancement-policy";
+export { Computed, Rule, } from "../advancement-policies/define-advancement-policy";
 type AnyTypedStep = TypedStepDefinitionSpec<any, any, any>;
 export type PipelineInputBinding = {
     source: "pipeline_input";
@@ -34,14 +34,6 @@ export declare function fromSignal<TStep extends AnyTypedStep>(step: TStep, sign
  * For a stable contract, prefer fromSignal() instead.
  */
 export declare function stepOutput(step: AnyTypedStep): StepOutputBinding;
-export type PipelineStepComputedSignalType = "average" | "weighted_average" | "sum" | "min" | "max" | "count" | "boolean_any" | "boolean_all";
-export type PipelineStepComputedSignalSpec<TSignalKey extends string = string> = {
-    key: string;
-    type: PipelineStepComputedSignalType;
-    inputSignalKeys: ReadonlyArray<TSignalKey>;
-    configJson?: Record<string, unknown> | null;
-    availableWhenResultStatusIn?: string[] | null;
-};
 export type PipelineStepConfig<TStep extends AnyTypedStep = AnyTypedStep> = {
     step: TStep;
     /** Maps each step input field to an input source. Extra keys are ignored at runtime. */
@@ -51,16 +43,13 @@ export type PipelineStepConfig<TStep extends AnyTypedStep = AnyTypedStep> = {
     timeout?: number | null;
     /**
      * Controls when and how this step advances in the pipeline.
-     * Signal keys in `whenSignal()` rules are type-checked against this step's declared signals.
+     * Signal keys in `Rule.signal()` / `Rule.when()` calls are type-checked
+     * against the step's declared signals. Inline `Computed.X(...)` tokens can
+     * also appear in the signal position; they're hoisted into the step's
+     * `computedSignalDefinitions` at serialization time.
      * Defaults to `{ defaultOutcome: "continue" }` when omitted.
      */
     advancement?: AdvancementPolicy<TStep["__signalKeys"]>;
-    /**
-     * Aggregations derived from this step's emitted signals (extractor keys plus any
-     * earlier computed-signal keys in this list). Each entry's `inputSignalKeys` is
-     * type-checked against the step's declared signal keys.
-     */
-    computedSignals?: ReadonlyArray<PipelineStepComputedSignalSpec<TStep["__signalKeys"]>>;
 };
 type SerializedBinding = {
     source: "pipeline_input";
@@ -73,13 +62,6 @@ type SerializedBinding = {
     source: "step_output";
     stepKey: string;
 };
-type SerializedComputedSignalDefinition = {
-    key: string;
-    type: PipelineStepComputedSignalType;
-    inputSignalKeys: string[];
-    configJson: Record<string, unknown> | null;
-    availableWhenResultStatusIn: string[] | null;
-};
 export type PipelineDefinitionSpec = {
     key: string;
     name: string;
@@ -114,7 +96,10 @@ export type DefinePipelineInput = {
  * Defines a pipeline from an ordered list of step configs.
  *
  * Each step's `advancement` policy is typed against that step's declared signal
- * keys — passing an unknown signal key to `whenSignal()` is a compile-time error.
+ * keys — passing an unknown signal key to `Rule.signal()` / `Rule.when()` is a
+ * compile-time error. Inline `Computed.X(...)` tokens can also be used in the
+ * signal position; they're walked out of the rules tree at serialization time
+ * and emitted as the step's `computedSignalDefinitions`.
  *
  * TypeScript achieves per-element signal key checking by constraining `TSteps`
  * to a tuple of step instances (`AnyTypedStep[]`), not step configs. Each element

package/dist/definitions/pipelines/index.js

@@ -14,6 +14,27 @@ var __export = (target, all) => {
 };
 
 // src/definitions/advancement-policies/define-advancement-policy.ts
+function makeComputed(type, inputSignalKeys, options) {
+  const key = [type, ...inputSignalKeys].join("_");
+  return {
+    _tag: "computed_signal",
+    key,
+    type,
+    inputSignalKeys,
+    configJson: options?.configJson ?? null,
+    availableWhenResultStatusIn: options?.availableWhenResultStatusIn ?? null
+  };
+}
+var Computed = {
+  average: (inputSignalKeys, options) => makeComputed("average", inputSignalKeys, options),
+  weightedAverage: (inputSignalKeys, options) => makeComputed("weighted_average", inputSignalKeys, options),
+  sum: (inputSignalKeys, options) => makeComputed("sum", inputSignalKeys, options),
+  min: (inputSignalKeys, options) => makeComputed("min", inputSignalKeys, options),
+  max: (inputSignalKeys, options) => makeComputed("max", inputSignalKeys, options),
+  count: (inputSignalKeys, options) => makeComputed("count", inputSignalKeys, options),
+  booleanAny: (inputSignalKeys, options) => makeComputed("boolean_any", inputSignalKeys, options),
+  booleanAll: (inputSignalKeys, options) => makeComputed("boolean_all", inputSignalKeys, options)
+};
 function signal(signal2, operator, value) {
   return { _tag: "signal", signal: signal2, operator, value };
 }
@@ -47,7 +68,7 @@ function resolveOutcome(outcome) {
 function serializeCondition(condition) {
   if (condition._tag === "signal") {
     return {
-      fact: condition.signal,
+      fact: typeof condition.signal === "string" ? condition.signal : condition.signal.key,
       operator: condition.operator,
       value: condition.value
     };
@@ -89,6 +110,46 @@ function serializeAdvancementPolicy(policy) {
     allowedEventTypes: [...outcomeSet]
   };
 }
+function visitSignalConditions(conditions, visit) {
+  for (const c of conditions) {
+    if (c._tag === "signal") {
+      visit(c);
+    } else {
+      visitSignalConditions(c.conditions, visit);
+    }
+  }
+}
+function isSameComputedDefinition(a, b) {
+  return a.type === b.type && a.inputSignalKeys.length === b.inputSignalKeys.length && a.inputSignalKeys.every((k, i) => k === b.inputSignalKeys[i]) && JSON.stringify(a.configJson) === JSON.stringify(b.configJson) && JSON.stringify(a.availableWhenResultStatusIn) === JSON.stringify(b.availableWhenResultStatusIn);
+}
+function extractInlineComputedSignals(policy) {
+  if (!policy?.rules)
+    return [];
+  const byKey = new Map;
+  for (const rule of policy.rules) {
+    visitSignalConditions(rule.conditions, (cond) => {
+      if (typeof cond.signal === "string")
+        return;
+      const inline = cond.signal;
+      const def = {
+        key: inline.key,
+        type: inline.type,
+        inputSignalKeys: [...inline.inputSignalKeys],
+        configJson: inline.configJson,
+        availableWhenResultStatusIn: inline.availableWhenResultStatusIn ? [...inline.availableWhenResultStatusIn] : null
+      };
+      const existing = byKey.get(def.key);
+      if (existing) {
+        if (!isSameComputedDefinition(existing, def)) {
+          throw new Error(`Conflicting inline computed signal definitions for key "${def.key}"`);
+        }
+        return;
+      }
+      byKey.set(def.key, def);
+    });
+  }
+  return [...byKey.values()];
+}
 
 // src/definitions/pipelines/define-pipeline.ts
 function fromPipelineInput(_schema, path) {
@@ -129,13 +190,7 @@ function definePipeline(config) {
       inputBindingsJson: Object.fromEntries(Object.entries(stepConfig.input ?? {}).filter((entry) => entry[1] !== undefined).map(([key, binding]) => [key, serializeBinding(binding)])),
       timeoutSeconds: stepConfig.timeout ?? null,
       advancementPolicyDefinition: serializeAdvancementPolicy(stepConfig.advancement),
-      computedSignalDefinitions: (stepConfig.computedSignals ?? []).map((cs) => ({
-        key: cs.key,
-        type: cs.type,
-        inputSignalKeys: [...cs.inputSignalKeys],
-        configJson: cs.configJson ?? null,
-        availableWhenResultStatusIn: cs.availableWhenResultStatusIn ?? null
-      }))
+      computedSignalDefinitions: extractInlineComputedSignals(stepConfig.advancement)
     }))
   };
 }
@@ -186,5 +241,6 @@ export {
   fromPipelineInput,
   definePipeline,
   createPipelineDefinitionsClient,
-  Rule
+  Rule,
+  Computed
 };

package/dist/index.js

@@ -15797,6 +15797,27 @@ var Features = {
   })
 };
 // src/definitions/advancement-policies/define-advancement-policy.ts
+function makeComputed(type, inputSignalKeys, options) {
+  const key = [type, ...inputSignalKeys].join("_");
+  return {
+    _tag: "computed_signal",
+    key,
+    type,
+    inputSignalKeys,
+    configJson: options?.configJson ?? null,
+    availableWhenResultStatusIn: options?.availableWhenResultStatusIn ?? null
+  };
+}
+var Computed = {
+  average: (inputSignalKeys, options) => makeComputed("average", inputSignalKeys, options),
+  weightedAverage: (inputSignalKeys, options) => makeComputed("weighted_average", inputSignalKeys, options),
+  sum: (inputSignalKeys, options) => makeComputed("sum", inputSignalKeys, options),
+  min: (inputSignalKeys, options) => makeComputed("min", inputSignalKeys, options),
+  max: (inputSignalKeys, options) => makeComputed("max", inputSignalKeys, options),
+  count: (inputSignalKeys, options) => makeComputed("count", inputSignalKeys, options),
+  booleanAny: (inputSignalKeys, options) => makeComputed("boolean_any", inputSignalKeys, options),
+  booleanAll: (inputSignalKeys, options) => makeComputed("boolean_all", inputSignalKeys, options)
+};
 function signal(signal2, operator, value) {
   return { _tag: "signal", signal: signal2, operator, value };
 }
@@ -15830,7 +15851,7 @@ function resolveOutcome(outcome) {
 function serializeCondition(condition) {
   if (condition._tag === "signal") {
     return {
-      fact: condition.signal,
+      fact: typeof condition.signal === "string" ? condition.signal : condition.signal.key,
       operator: condition.operator,
       value: condition.value
     };
@@ -15872,6 +15893,46 @@ function serializeAdvancementPolicy(policy) {
     allowedEventTypes: [...outcomeSet]
   };
 }
+function visitSignalConditions(conditions, visit) {
+  for (const c of conditions) {
+    if (c._tag === "signal") {
+      visit(c);
+    } else {
+      visitSignalConditions(c.conditions, visit);
+    }
+  }
+}
+function isSameComputedDefinition(a, b) {
+  return a.type === b.type && a.inputSignalKeys.length === b.inputSignalKeys.length && a.inputSignalKeys.every((k, i) => k === b.inputSignalKeys[i]) && JSON.stringify(a.configJson) === JSON.stringify(b.configJson) && JSON.stringify(a.availableWhenResultStatusIn) === JSON.stringify(b.availableWhenResultStatusIn);
+}
+function extractInlineComputedSignals(policy) {
+  if (!policy?.rules)
+    return [];
+  const byKey = new Map;
+  for (const rule of policy.rules) {
+    visitSignalConditions(rule.conditions, (cond) => {
+      if (typeof cond.signal === "string")
+        return;
+      const inline = cond.signal;
+      const def = {
+        key: inline.key,
+        type: inline.type,
+        inputSignalKeys: [...inline.inputSignalKeys],
+        configJson: inline.configJson,
+        availableWhenResultStatusIn: inline.availableWhenResultStatusIn ? [...inline.availableWhenResultStatusIn] : null
+      };
+      const existing = byKey.get(def.key);
+      if (existing) {
+        if (!isSameComputedDefinition(existing, def)) {
+          throw new Error(`Conflicting inline computed signal definitions for key "${def.key}"`);
+        }
+        return;
+      }
+      byKey.set(def.key, def);
+    });
+  }
+  return [...byKey.values()];
+}
 
 // src/definitions/pipelines/define-pipeline.ts
 function fromPipelineInput(_schema, path) {
@@ -15912,13 +15973,7 @@ function definePipeline(config2) {
       inputBindingsJson: Object.fromEntries(Object.entries(stepConfig.input ?? {}).filter((entry) => entry[1] !== undefined).map(([key, binding]) => [key, serializeBinding(binding)])),
       timeoutSeconds: stepConfig.timeout ?? null,
       advancementPolicyDefinition: serializeAdvancementPolicy(stepConfig.advancement),
-      computedSignalDefinitions: (stepConfig.computedSignals ?? []).map((cs) => ({
-        key: cs.key,
-        type: cs.type,
-        inputSignalKeys: [...cs.inputSignalKeys],
-        configJson: cs.configJson ?? null,
-        availableWhenResultStatusIn: cs.availableWhenResultStatusIn ?? null
-      }))
+      computedSignalDefinitions: extractInlineComputedSignals(stepConfig.advancement)
     }))
   };
 }
@@ -16633,6 +16688,7 @@ export {
   PipelineDefinitions,
   FeedbackRequests,
   Features,
+  Computed,
   BoboddyClient,
   BOBODDY_CONFIG_RELATIVE_PATH,
   Api

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "@boboddy/sdk",
-  "version": "0.1.6-alpha",
+  "version": "0.1.7-alpha",
   "type": "module",
   "exports": {
     ".": {