@akemi-mio/creativity 0.0.0-stage → 0.1.1

package/dist/WhenThenRunner.js

@@ -0,0 +1,358 @@
+"use strict";
+/**
+ * WhenThenRunner — 声明式 WHEN/THEN 受限 DSL 运行器（机制涌现 P2a，定案 D5/R5/A2）
+ *
+ * 候选执行不写任意代码：DSL 查表求值（阈值比较 + 字段存在性 + 枚举匹配，禁 JS eval）。
+ * 步骤依赖执行 + 显式 named outputs（无隐式上下文注入）。
+ * resourceBudget 编译为 CapabilityToken.constraints。
+ * 求值器输入输出全白名单序列化（JSON number/boolean/string）。
+ * 条件字符串长度上限，解析失败 = fail-closed（步骤跳过 + 记 guardrail 事件，不中断实验、不泄漏沙箱内部）。
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAX_CONDITION_LIST_LEN = exports.MAX_CONDITION_STRING_VALUE_LEN = exports.MAX_CONDITION_FIELD_LEN = void 0;
+exports.lookupField = lookupField;
+exports.evaluateCondition = evaluateCondition;
+exports.evaluateWhen = evaluateWhen;
+exports.compileBudgetToConstraints = compileBudgetToConstraints;
+exports.topologicalOrder = topologicalOrder;
+exports.runWhenThenRule = runWhenThenRule;
+// ══════════════════════════════════════════
+// 求值器（白名单查表，禁 eval）
+// ══════════════════════════════════════════
+/** 条件字符串长度上限（防超长注入） */
+exports.MAX_CONDITION_FIELD_LEN = 128;
+exports.MAX_CONDITION_STRING_VALUE_LEN = 512;
+exports.MAX_CONDITION_LIST_LEN = 32;
+function isScalar(v) {
+    return typeof v === 'number' || typeof v === 'boolean' || typeof v === 'string';
+}
+/** 按点分路径从 context 取值；中间路径不存在返回 undefined。不深入数组索引（防原型链）。 */
+function lookupField(context, field) {
+    if (typeof field !== 'string' || field.length === 0 || field.length > exports.MAX_CONDITION_FIELD_LEN)
+        return undefined;
+    // 禁原型链：字段不得含 `__proto__` / `constructor` / `prototype`
+    if (field.includes('__proto__') || field.includes('constructor') || field.includes('prototype'))
+        return undefined;
+    const parts = field.split('.');
+    let cur = context;
+    for (const p of parts) {
+        if (cur === null || typeof cur !== 'object' || Array.isArray(cur))
+            return undefined;
+        const obj = cur;
+        if (!Object.prototype.hasOwnProperty.call(obj, p))
+            return undefined;
+        cur = obj[p];
+    }
+    return cur;
+}
+/** 求值单个 WHEN 条件；解析失败（非法字段/值/操作符）返回 null（调用方 fail-closed）。 */
+function evaluateCondition(context, cond) {
+    if (!cond || typeof cond !== 'object')
+        return null;
+    const { field, op, value } = cond;
+    if (typeof field !== 'string' || field.length === 0 || field.length > exports.MAX_CONDITION_FIELD_LEN)
+        return null;
+    if (field.includes('__proto__') || field.includes('constructor') || field.includes('prototype'))
+        return null;
+    const actual = lookupField(context, field);
+    switch (op) {
+        case 'exists':
+            return actual !== undefined && actual !== null;
+        case 'notExists':
+            return actual === undefined || actual === null;
+        case 'eq':
+        case 'neq':
+        case 'gt':
+        case 'gte':
+        case 'lt':
+        case 'lte': {
+            if (!isScalar(value))
+                return null;
+            if (!isScalar(actual))
+                return false;
+            switch (op) {
+                case 'eq':
+                    return actual === value;
+                case 'neq':
+                    return actual !== value;
+                case 'gt':
+                    return typeof actual === 'number' && typeof value === 'number' && actual > value;
+                case 'gte':
+                    return typeof actual === 'number' && typeof value === 'number' && actual >= value;
+                case 'lt':
+                    return typeof actual === 'number' && typeof value === 'number' && actual < value;
+                case 'lte':
+                    return typeof actual === 'number' && typeof value === 'number' && actual <= value;
+                default:
+                    return null;
+            }
+        }
+        case 'in':
+        case 'nin': {
+            if (!Array.isArray(value) || value.length > exports.MAX_CONDITION_LIST_LEN)
+                return null;
+            if (!value.every((v) => typeof v === 'string' && v.length <= exports.MAX_CONDITION_STRING_VALUE_LEN))
+                return null;
+            if (!isScalar(actual))
+                return false;
+            const hit = value.includes(actual);
+            return op === 'in' ? hit : !hit;
+        }
+        default:
+            // 未知操作符 = 解析失败
+            return null;
+    }
+}
+/** 求值全部 WHEN 条件（AND）；任一解析失败返回 null（fail-closed）。 */
+function evaluateWhen(context, when) {
+    if (!when || when.length === 0)
+        return true;
+    for (const c of when) {
+        const r = evaluateCondition(context, c);
+        if (r === null)
+            return null;
+        if (r === false)
+            return false;
+    }
+    return true;
+}
+// ══════════════════════════════════════════
+// resourceBudget → CapabilityToken.constraints
+// ══════════════════════════════════════════
+/** 把 ResourceBudgetSpec 编译为 CapabilityToken.constraints（白名单字段）。 */
+function compileBudgetToConstraints(budget, ruleBudget) {
+    // 步骤级覆盖规则级
+    const b = budget ?? ruleBudget;
+    if (!b)
+        return undefined;
+    const constraints = {};
+    if (typeof b.maxCalls === 'number' && Number.isFinite(b.maxCalls) && b.maxCalls >= 0) {
+        constraints.maxCalls = Math.floor(b.maxCalls);
+    }
+    if (typeof b.maxTokens === 'number' && Number.isFinite(b.maxTokens) && b.maxTokens >= 0) {
+        constraints.maxTokens = Math.floor(b.maxTokens);
+    }
+    if (typeof b.expiryMs === 'number' && Number.isFinite(b.expiryMs) && b.expiryMs >= 0) {
+        constraints.expiryMs = Math.floor(b.expiryMs);
+    }
+    if (b.allowedValues && typeof b.allowedValues === 'object' && !Array.isArray(b.allowedValues)) {
+        const allowed = {};
+        for (const [k, arr] of Object.entries(b.allowedValues)) {
+            if (Array.isArray(arr) && arr.every((v) => typeof v === 'string' && v.length <= exports.MAX_CONDITION_STRING_VALUE_LEN)) {
+                if (arr.length <= exports.MAX_CONDITION_LIST_LEN)
+                    allowed[k] = arr;
+            }
+        }
+        if (Object.keys(allowed).length > 0)
+            constraints.allowedValues = allowed;
+    }
+    return Object.keys(constraints).length > 0 ? constraints : undefined;
+}
+// ══════════════════════════════════════════
+// 依赖调度（DAG 拓扑 + named outputs）
+// ══════════════════════════════════════════
+/** 拓扑排序步骤；环路/未知依赖返回 null（fail-closed）。 */
+function topologicalOrder(steps) {
+    const byId = new Map();
+    for (const s of steps) {
+        if (!s || typeof s.id !== 'string' || s.id.length === 0)
+            return null;
+        if (byId.has(s.id))
+            return null;
+        byId.set(s.id, s);
+    }
+    const indegree = new Map();
+    const children = new Map();
+    for (const s of steps) {
+        indegree.set(s.id, 0);
+    }
+    for (const s of steps) {
+        const deps = s.dependsOn ?? [];
+        for (const d of deps) {
+            if (!byId.has(d))
+                return null; // 未知依赖
+            indegree.set(s.id, (indegree.get(s.id) ?? 0) + 1);
+            const list = children.get(d) ?? [];
+            list.push(s.id);
+            children.set(d, list);
+        }
+    }
+    const queue = [];
+    for (const [id, deg] of indegree) {
+        if (deg === 0)
+            queue.push(id);
+    }
+    queue.sort();
+    const order = [];
+    while (queue.length > 0) {
+        const id = queue.shift();
+        order.push(byId.get(id));
+        for (const child of children.get(id) ?? []) {
+            const nd = (indegree.get(child) ?? 1) - 1;
+            indegree.set(child, nd);
+            if (nd === 0)
+                queue.push(child);
+        }
+        queue.sort();
+    }
+    if (order.length !== steps.length)
+        return null; // 环
+    return order;
+}
+/**
+ * 执行一条 WHEN/THEN 规则。
+ *
+ * - 按 DAG 拓扑顺序调度
+ * - 每步先求值 WHEN（解析失败 → fail-closed skip + guardrail 事件）
+ * - 输入从初始 context + 上游 named outputs 显式解析（无隐式注入）
+ * - 预算编译为 CapabilityToken.constraints 传给 executor
+ * - 任一步失败不中断实验：后续依赖步骤 blocked，独立步骤继续
+ */
+async function runWhenThenRule(rule, context, executeStep, options) {
+    const events = [];
+    const namedOutputs = { ...(options?.initialOutputs ?? {}) };
+    const stepStatus = new Map();
+    const stepReason = new Map();
+    const stepOutputs = new Map();
+    const sink = (ev) => {
+        events.push(ev);
+        options?.onEvent?.(ev);
+    };
+    // 1. 拓扑排序（环/未知依赖 → 整规则 fail-closed）
+    const order = topologicalOrder(rule.steps ?? []);
+    if (!order) {
+        sink({
+            event_type: 'whenthen.rule.failed',
+            rule_id: rule.id,
+            reason: 'invalid_graph',
+            outcome: 'failed',
+            timestamp: Date.now(),
+        });
+        return { success: false, namedOutputs, steps: [], events };
+    }
+    // 2. 逐步骤
+    for (const step of order) {
+        const deps = step.dependsOn ?? [];
+        const depBlocked = deps.some((d) => {
+            const st = stepStatus.get(d);
+            return st === 'failed' || st === 'blocked' || st === 'skipped';
+        });
+        if (depBlocked) {
+            stepStatus.set(step.id, 'blocked');
+            stepReason.set(step.id, 'upstream_blocked');
+            sink({
+                event_type: 'whenthen.step.skipped',
+                rule_id: rule.id,
+                step_id: step.id,
+                reason: 'upstream_blocked',
+                outcome: 'skipped',
+                timestamp: Date.now(),
+            });
+            continue;
+        }
+        // 3. WHEN 求值（fail-closed）
+        const whenOk = evaluateWhen(context, step.when);
+        if (whenOk === null) {
+            stepStatus.set(step.id, 'skipped');
+            stepReason.set(step.id, 'when_parse_failed');
+            sink({
+                event_type: 'whenthen.step.skipped',
+                rule_id: rule.id,
+                step_id: step.id,
+                reason: 'when_parse_failed',
+                outcome: 'skipped',
+                timestamp: Date.now(),
+            });
+            continue;
+        }
+        if (whenOk === false) {
+            stepStatus.set(step.id, 'skipped');
+            stepReason.set(step.id, 'when_not_satisfied');
+            sink({
+                event_type: 'whenthen.step.skipped',
+                rule_id: rule.id,
+                step_id: step.id,
+                reason: 'when_not_satisfied',
+                outcome: 'skipped',
+                timestamp: Date.now(),
+            });
+            continue;
+        }
+        // 4. 显式 named inputs 解析（路径 = 初始 context 或 namedOutputs）
+        const inputs = {};
+        if (step.inputs) {
+            for (const [name, path] of Object.entries(step.inputs)) {
+                if (typeof path !== 'string' || path.length === 0 || path.length > exports.MAX_CONDITION_FIELD_LEN)
+                    continue;
+                if (path.includes('__proto__') || path.includes('constructor') || path.includes('prototype'))
+                    continue;
+                const v = lookupField(namedOutputs, path) ?? lookupField(context, path);
+                if (v !== undefined)
+                    inputs[name] = v;
+            }
+        }
+        // 5. 预算编译
+        const constraints = compileBudgetToConstraints(step.resourceBudget, rule.resourceBudget);
+        // 6. 执行
+        try {
+            const result = await executeStep({
+                stepId: step.id,
+                capabilityId: step.capabilityId,
+                inputs,
+                constraints,
+            });
+            if (result.success) {
+                stepStatus.set(step.id, 'ok');
+                const outs = result.outputs ?? {};
+                stepOutputs.set(step.id, outs);
+                for (const [k, v] of Object.entries(outs)) {
+                    namedOutputs[k] = v;
+                    namedOutputs[`${step.id}.${k}`] = v;
+                }
+            }
+            else {
+                stepStatus.set(step.id, 'failed');
+                stepReason.set(step.id, result.error ?? 'step_failed');
+                sink({
+                    event_type: 'whenthen.step.failed',
+                    rule_id: rule.id,
+                    step_id: step.id,
+                    reason: result.error ?? 'step_failed',
+                    outcome: 'failed',
+                    timestamp: Date.now(),
+                });
+            }
+        }
+        catch {
+            stepStatus.set(step.id, 'failed');
+            stepReason.set(step.id, 'step_exception');
+            sink({
+                event_type: 'whenthen.step.failed',
+                rule_id: rule.id,
+                step_id: step.id,
+                reason: 'step_exception',
+                outcome: 'failed',
+                timestamp: Date.now(),
+            });
+        }
+    }
+    const allOk = order.every((s) => stepStatus.get(s.id) === 'ok' || stepStatus.get(s.id) === 'skipped');
+    sink({
+        event_type: allOk ? 'whenthen.rule.complete' : 'whenthen.rule.failed',
+        rule_id: rule.id,
+        reason: allOk ? 'complete' : 'partial_failure',
+        outcome: allOk ? 'success' : 'partial',
+        timestamp: Date.now(),
+    });
+    return {
+        success: allOk,
+        namedOutputs,
+        steps: order.map((s) => ({
+            id: s.id,
+            status: stepStatus.get(s.id) ?? 'blocked',
+            reason: stepReason.get(s.id),
+            outputs: stepOutputs.get(s.id),
+        })),
+        events,
+    };
+}

package/dist/types.d.ts

@@ -0,0 +1,213 @@
+/**
+ * 生成策略 �?�?ConceptMixer 之前选择，约束配对空�?
+ * - stable:   同类型组合，禁止 novelty bonus 主导，输出收�?
+ * - explore:  跨类型组合，提高 diversity weight，允许结构差�?
+ * - signal:   强制注入 trend/ provocation/insight 来源，限�?randomness
+ */
+export type Strategy = 'stable' | 'explore' | 'signal';
+export interface CreativitySource {
+    name: string;
+    content: string;
+    fullContent?: string;
+    sourceDepth?: 'shallow' | 'medium' | 'full';
+    type: 'knowledge' | 'behavior' | 'insight' | 'failure' | 'random' | 'provocation' | 'feedback';
+    weight: number;
+    /** Provider + record id, e.g. `memory:mem_1791…`. Required on auto-aggregated sources (spec Capability 2). */
+    origin?: string;
+    /** Original record id for back-referencing. */
+    originId?: string;
+    /** 0-1 credibility hint; omit when unknowable. */
+    confidence?: number;
+    /** Source record time, ISO 8601. */
+    timestamp?: string;
+}
+/** Where and how an idea.generate result was produced (spec Capability 1). */
+export interface HypothesisProvenance {
+    /** Pairing strategy used to build source combos: explore | stable | signal. */
+    strategy?: string;
+    /** Rotation technique used for the prompt (mirrors `Hypothesis.technique`). */
+    technique?: string;
+    /** Memory record ids that grounded the goal (0-3, newest first). */
+    relatedMemoryIds?: string[];
+    /** Assembled sources that fed generation, filtered to the labels actually used. */
+    sources?: Array<{
+        name: string;
+        type: string;
+        origin?: string;
+        timestamp?: string;
+    }>;
+    /** When the idea was generated, ISO 8601. */
+    generatedAt?: string;
+}
+export interface ConceptCombo {
+    id: string;
+    sources: [string, string];
+    description: string;
+    createdAt: number;
+}
+export type FermentVerdict = 'promote' | 'keep' | 'reject' | 'merge';
+export interface FermentLogEntry {
+    at: number;
+    verdict: FermentVerdict;
+    reason: string;
+    score?: {
+        novelty: number;
+        feasibility: number;
+        impact: number;
+        logic?: number;
+    };
+}
+export interface HypothesisFermentationPatch {
+    status?: Hypothesis['status'];
+    fermentCount?: number;
+    lastFermentedAt?: number;
+    fermentLog?: FermentLogEntry[];
+    idea?: string;
+    novelty?: number;
+    feasibility?: number;
+    impact?: number;
+    logic?: number;
+    mergedInto?: string;
+}
+export interface Hypothesis {
+    id: string;
+    title: string;
+    idea: string;
+    expectedBenefit: string;
+    risk: string;
+    sourceLabels: string[];
+    sourceDetails?: Array<{
+        name: string;
+        depth: 'shallow' | 'medium' | 'full';
+    }>;
+    novelty: number;
+    feasibility: number;
+    impact: number;
+    /** 逻辑一致性评分 0-100（第四维，评审/生成时打分，可缺省视为 50） */
+    logic?: number;
+    status: 'draft' | 'active' | 'testing' | 'validated' | 'rejected';
+    createdAt: number;
+    /** The rotation technique this hypothesis was generated with (idea.generate provenance.technique). */
+    technique?: string;
+    /** Idea-generation provenance; `mio.idea.generate` persists this with the record. */
+    provenance?: HypothesisProvenance;
+    /** 实现难度 1-5（LLM 生成�?*/
+    implementationDifficulty?: number;
+    /** 预计开发时间（LLM 生成，如 "1-2�?�?*/
+    estimatedDevTime?: string;
+    /** 多视角评估（LLM 生成�?*/
+    perspectives?: {
+        self: string;
+        user: string;
+        maintainer: string;
+    };
+    /** 已发酵轮�?*/
+    fermentCount?: number;
+    /** 最近发酵时间戳 */
+    lastFermentedAt?: number;
+    /** 发酵历史记录 */
+    fermentLog?: FermentLogEntry[];
+    /** merge 后指向的�?hypothesis id */
+    mergedInto?: string;
+    implementedCommitSha?: string;
+    implementedAt?: number;
+    implementationNote?: string;
+    /** 机制假设：提出的关系边（带 proposedRelations 即机制假设，否则普通创意） */
+    proposedRelations?: ProposedRelation[];
+    /** 证伪条件：命中任一条件则机制假设可被拒绝 */
+    falsificationConditions?: string[];
+    /** 触发本假设的 observation/trace id 溯源 */
+    sourceObservationIds?: string[];
+}
+/** 机制图的一条候选边：A --[effect]--> B */
+export interface ProposedRelation {
+    from: string;
+    to: string;
+    effect: string;
+    /** 推断来源：identity=verified | inferred（A6 confidence 映射） */
+    inference?: 'identity' | 'inferred';
+}
+export interface ExperimentPlan {
+    hypothesisId: string;
+    title: string;
+    steps: string[];
+    successCriteria: string[];
+    estimatedDuration: string;
+    createdAt: number;
+}
+export interface CreativeIdea {
+    hypothesis: Hypothesis;
+    experiment: ExperimentPlan | null;
+}
+export interface DreamCycleLog {
+    timestamp: number;
+    sourcesExamined: number;
+    combosGenerated: number;
+    hypothesesGenerated: number;
+    topIdea: string | null;
+}
+export interface IdeaStoreLike {
+    addCombo: (combo: ConceptCombo) => void;
+    addHypothesis: (h: Hypothesis) => void;
+    addManyHypotheses: (hs: Hypothesis[]) => void;
+    addExperiment: (exp: ExperimentPlan) => void;
+    logDreamCycle: (entry: DreamCycleLog) => void;
+    getHypotheses: (options?: {
+        status?: string;
+        limit?: number;
+    }) => Hypothesis[];
+    getNovelHypotheses: (threshold?: number, limit?: number) => Hypothesis[];
+    getActiveExperiments: () => ExperimentPlan[];
+    getRecentCombos: (limit?: number) => ConceptCombo[];
+    getRecentDreamCycles: (limit?: number) => DreamCycleLog[];
+    updateHypothesisStatus: (id: string, status: Hypothesis['status']) => boolean;
+    addExploredPair: (nameA: string, nameB: string) => void;
+    getExploredPairs: () => string[];
+    resetExploredPairs: () => void;
+    count: () => {
+        combos: number;
+        hypotheses: number;
+        experiments: number;
+        dreamCycles: number;
+    };
+    templateAdoptionStats: () => Record<string, {
+        total: number;
+        active: number;
+        rejected: number;
+        adopted: number;
+    }>;
+    adoptionReport: (limit?: number) => string;
+    getFermentableHypotheses: (limit?: number) => Hypothesis[];
+    updateHypothesisFermentation: (id: string, patch: HypothesisFermentationPatch) => boolean;
+}
+export interface CreativityStoreData {
+    version: number;
+    combos: ConceptCombo[];
+    hypotheses: Hypothesis[];
+    experiments: ExperimentPlan[];
+    dreamCycles: DreamCycleLog[];
+    exploredPairs: string[];
+}
+export declare const CREATIVITY_STORE_VERSION = 2;
+export declare const DREAM_CYCLE_INTERVAL_MS: number;
+export declare const NORMAL_CYCLE_INTERVAL_MS: number;
+export declare const FERMENT_INTERVAL_MS: number;
+/** 发酵与创意周期错峰偏移：避免同一时刻并发占用 code 模型上游 */
+export declare const FERMENT_PHASE_OFFSET_MS: number;
+/**
+ * 外部信号 �?不进入配对空�?
+ *
+ * Observer 的外部数据在此层保持�?不可配对"的原始语义，
+ * 直接注入 LLM 作为约束/挑战，而非组合概念�?
+ *
+ * �?CreativitySource 的关键区别：
+ * - 不能进入 ConceptMixer
+ * - 不参�?combinatorial pairing
+ * - 不参�?scoring/ranking
+ * - 只作�?prompt 中的"外部审视"�?
+ */
+export interface ExternalSignal {
+    source: string;
+    raw: string;
+    type: 'trend' | 'event' | 'anomaly' | 'insight';
+}

package/dist/types.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FERMENT_PHASE_OFFSET_MS = exports.FERMENT_INTERVAL_MS = exports.NORMAL_CYCLE_INTERVAL_MS = exports.DREAM_CYCLE_INTERVAL_MS = exports.CREATIVITY_STORE_VERSION = void 0;
+exports.CREATIVITY_STORE_VERSION = 2;
+exports.DREAM_CYCLE_INTERVAL_MS = 30 * 60 * 1000; // 30min
+exports.NORMAL_CYCLE_INTERVAL_MS = 5 * 60 * 1000; // 5min
+exports.FERMENT_INTERVAL_MS = 10 * 60 * 1000; // 10min
+/** 发酵与创意周期错峰偏移：避免同一时刻并发占用 code 模型上游 */
+exports.FERMENT_PHASE_OFFSET_MS = 2 * 60 * 1000; // 2min

package/package.json

@@ -1,6 +1,69 @@
 {
   "name": "@akemi-mio/creativity",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.1",
+  "description": "Creativity layer: ideas, writing, blog, image, inspiration",
+  "main": "./dist/IdeaGenerator.js",
+  "types": "./dist/IdeaGenerator.d.ts",
+  "exports": {
+    "./IdeaGenerator": {
+      "types": "./dist/IdeaGenerator.d.ts",
+      "require": "./dist/IdeaGenerator.js",
+      "default": "./dist/IdeaGenerator.js"
+    },
+    "./SourceAggregator": {
+      "types": "./dist/SourceAggregator.d.ts",
+      "require": "./dist/SourceAggregator.js",
+      "default": "./dist/SourceAggregator.js"
+    },
+    "./NoveltyScorer": {
+      "types": "./dist/NoveltyScorer.d.ts",
+      "require": "./dist/NoveltyScorer.js",
+      "default": "./dist/NoveltyScorer.js"
+    },
+    "./types": {
+      "types": "./dist/types.d.ts",
+      "require": "./dist/types.js",
+      "default": "./dist/types.js"
+    },
+    "./MechanismRegistry": {
+      "types": "./dist/MechanismRegistry.d.ts",
+      "require": "./dist/MechanismRegistry.js",
+      "default": "./dist/MechanismRegistry.js"
+    },
+    "./ExperimentRunStore": {
+      "types": "./dist/ExperimentRunStore.d.ts",
+      "require": "./dist/ExperimentRunStore.js",
+      "default": "./dist/ExperimentRunStore.js"
+    },
+    "./WhenThenRunner": {
+      "types": "./dist/WhenThenRunner.d.ts",
+      "require": "./dist/WhenThenRunner.js",
+      "default": "./dist/WhenThenRunner.js"
+    },
+    "./MechanismGraph": {
+      "types": "./dist/MechanismGraph.d.ts",
+      "require": "./dist/MechanismGraph.js",
+      "default": "./dist/MechanismGraph.js"
+    },
+    "./InsightSamplingExperiment": {
+      "types": "./dist/InsightSamplingExperiment.d.ts",
+      "require": "./dist/InsightSamplingExperiment.js",
+      "default": "./dist/InsightSamplingExperiment.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "prepublishOnly": "npm run build"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "license": "MIT",
+  "dependencies": {
+    "@akemi-mio/core": "^0.1.0"
+  }
+}

package/README.md

@@ -1,3 +0,0 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.