@stalfh233/omc-cli 0.0.0-stage → 0.4.10

package/dist/bench/scenario.js

@@ -0,0 +1,343 @@
+/**
+ * Canonical bench scenario — the business demo the whole tool surface is
+ * built around: 客户/项目/产出申报 three models, modeling + publish, the
+ * data loop (save/list/update), a DYNAMIC cross-model backfill rule, and the
+ * two-phase workflow approval (draft save -> start submit -> approval todo ->
+ * COMPLETED). Fixtures carry the `omc_mcp_` prefix; live runs clean up via
+ * model physical-delete cascade with absence readback.
+ */
+// Fixture codes carry a per-run nonce: the platform's physical-delete cascade
+// can orphan a deleted model's default data items (301012 默认数据项不可删除 —
+// they are uncleanable and block re-creation with 601001 模型编码重复), so a
+// fresh run must never race the previous run's residue. Override with
+// OMC_BENCH_FIXTURE for deliberate reuse.
+const RUN_NONCE = process.env.OMC_BENCH_FIXTURE ?? `${new Date().toISOString().slice(2, 10).replaceAll("-", "")}${Math.random().toString(36).slice(2, 6)}`;
+const CUSTOMER = `omc_mcp_bcust_${RUN_NONCE}`;
+const PROJECT = `omc_mcp_bproj_${RUN_NONCE}`;
+const DECLARATION = `omc_mcp_bdecl_${RUN_NONCE}`;
+const WORKFLOW = `omc_mcp_bwf_${RUN_NONCE}`;
+const NO_ASSERTIONS = () => undefined;
+class StepRunner {
+    harness;
+    steps = [];
+    #aborted = false;
+    constructor(harness) {
+        this.harness = harness;
+    }
+    get aborted() {
+        return this.#aborted;
+    }
+    /**
+     * One scenario step: governed tool call (auto-approved fixture loop) +
+     * soft assertions. A failed tool call aborts the scenario (later steps
+     * depend on it); failed assertions do not.
+     */
+    async step(id, tool, args, assertions = NO_ASSERTIONS, options = {}) {
+        if (this.#aborted && !options.cleanup)
+            return {};
+        const started = performance.now();
+        let passed = 0;
+        let failed = 0;
+        const failures = [];
+        const check = (description, fn) => {
+            try {
+                fn();
+                passed += 1;
+            }
+            catch (error) {
+                failed += 1;
+                failures.push(`${description}: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        };
+        let result = {};
+        let ok = false;
+        let errorMessage;
+        try {
+            result = await this.harness.call(tool, args, { approve: true });
+            ok = result.status === "ok";
+            if (!ok)
+                errorMessage = `${result.status}${result.blocker ? `/${String(result.blocker)}` : ""}${result.message ? ` ${String(result.message).slice(0, 200)}` : ""}`;
+            if (ok)
+                assertions(result, check);
+        }
+        catch (error) {
+            errorMessage = error instanceof Error ? error.message : String(error);
+        }
+        const record = {
+            id,
+            tool,
+            status: ok ? "ok" : "failed",
+            ok,
+            durationMs: performance.now() - started,
+            responseBytes: Buffer.from(JSON.stringify(result) ?? "null").length,
+            assertionsPassed: passed,
+            assertionsFailed: failed,
+            ...(errorMessage ? { error: errorMessage } : {}),
+        };
+        if (!options.cleanup) {
+            this.steps.push(record);
+            if (failures.length > 0)
+                this.steps[this.steps.length - 1] = { ...record, error: [...(record.error ? [record.error] : []), ...failures].join(" | ") };
+            if (!ok)
+                this.#aborted = true;
+        }
+        return result;
+    }
+}
+function performField(result, field) {
+    const value = result.performed?.[field];
+    return typeof value === "string" ? value : "";
+}
+function readbackField(result, field) {
+    return result.readback?.[field];
+}
+function workItemIdOf(item) {
+    return typeof item?.workItemId === "string" ? item.workItemId : typeof item?.id === "string" ? item.id : "";
+}
+function requireId(value) {
+    if (!value)
+        throw new Error("missing id");
+}
+export async function runScenario(harness) {
+    const runner = new StepRunner(harness);
+    const live = harness.mode === "live-sample";
+    // --- modeling: three models, business fields, publish, default forms ---
+    await runner.step("model-customer", "model.create", { name: "基准客户", code: CUSTOMER });
+    await runner.step("model-project", "model.create", { name: "基准项目", code: PROJECT });
+    await runner.step("model-declaration", "model.create", { name: "基准产出申报", code: DECLARATION });
+    await runner.step("field-customer-name", "field.create", { schemaCode: CUSTOMER, code: "custName", name: "客户名称", propertyType: "SHORT_TEXT" });
+    await runner.step("field-customer-grade", "field.create", { schemaCode: CUSTOMER, code: "creditGrade", name: "信用等级", propertyType: "RADIO", choices: ["A", "B", "C"] });
+    await runner.step("field-project-name", "field.create", { schemaCode: PROJECT, code: "projectName", name: "项目名称", propertyType: "SHORT_TEXT" });
+    await runner.step("field-project-period", "field.create", { schemaCode: PROJECT, code: "latestPeriod", name: "最近申报期", propertyType: "SHORT_TEXT" });
+    await runner.step("field-decl-period", "field.create", { schemaCode: DECLARATION, code: "declarePeriod", name: "申报期", propertyType: "SHORT_TEXT" });
+    await runner.step("field-decl-amount", "field.create", { schemaCode: DECLARATION, code: "amount", name: "申报金额", propertyType: "NUMERICAL", options: { scale: 2 } });
+    await runner.step("field-decl-project", "field.create", {
+        schemaCode: DECLARATION,
+        code: "project",
+        name: "所属项目",
+        propertyType: "WORK_SHEET",
+        relativeCode: PROJECT,
+        options: { schemaCode: PROJECT, queryCode: PROJECT, displayField: "projectName" },
+    });
+    await runner.step("field-publish-customer", "field.publish", { schemaCode: CUSTOMER });
+    await runner.step("field-publish-project", "field.publish", { schemaCode: PROJECT });
+    await runner.step("field-publish-declaration", "field.publish", { schemaCode: DECLARATION });
+    await runner.step("form-draft-customer", "form.draft", { schemaCode: CUSTOMER, sheetCode: CUSTOMER });
+    await runner.step("form-publish-customer", "form.publish", { schemaCode: CUSTOMER, sheetCode: CUSTOMER });
+    await runner.step("form-draft-project", "form.draft", { schemaCode: PROJECT, sheetCode: PROJECT });
+    await runner.step("form-publish-project", "form.publish", { schemaCode: PROJECT, sheetCode: PROJECT });
+    await runner.step("form-draft-declaration", "form.draft", { schemaCode: DECLARATION, sheetCode: DECLARATION });
+    await runner.step("form-publish-declaration", "form.publish", { schemaCode: DECLARATION, sheetCode: DECLARATION });
+    // Ticket 07 live knowledge: a fresh model's default list view has no
+    // business columns — configure them or the list projection reads back null.
+    // Live fidelity: CloudPivot seeds 13 system data items on every fresh model
+    // (including `name` 数据标题), so business fields use non-system codes.
+    await runner.step("listview-configure-customer", "listview.configure", { schemaCode: CUSTOMER, fieldCodes: ["custName", "creditGrade"] });
+    // --- data loop: customer + project rows, filtered list ---
+    const customer = await runner.step("data-save-customer", "data.save", { schemaCode: CUSTOMER, formData: { custName: "基准客户A", creditGrade: "A" } }, (result, check) => {
+        check("customer row id returned", () => requireId(performField(result, "bizObjectId")));
+    });
+    void customer;
+    // Live rule semantics: a business-rule UPDATE target query only sees
+    // non-DRAFT rows (BizObjectUtil filters PROCESSING/COMPLETED), so the
+    // backfill target is created AND submitted (in-place, no workflow) in one
+    // step — data.save alone would leave it DRAFT and invisible to the rule.
+    const project = await runner.step("data-submit-project", "data.submit", { schemaCode: PROJECT, formData: { projectName: "基准项目P1", latestPeriod: "" } }, (result, check) => {
+        check("project row id returned", () => requireId(performField(result, "bizObjectId") || readbackField(result, "objectId")));
+        check("project row COMPLETED", () => {
+            const status = readbackField(result, "sequenceStatus");
+            if (status !== "COMPLETED")
+                throw new Error(`sequenceStatus=${String(status)}`);
+        });
+    });
+    const projectId = performField(project, "bizObjectId") || readbackField(project, "objectId");
+    await runner.step("data-list-customer", "data.list", { schemaCode: CUSTOMER, filter: { op: "eq", field: "custName", value: "基准客户A" } }, (result, check) => {
+        const items = result.items;
+        check("filtered list hits exactly one row", () => {
+            if (!items || items.length !== 1)
+                throw new Error(`expected 1 item, got ${items?.length ?? "none"}`);
+        });
+        check("list projection echoes the business field", () => {
+            if (items?.[0]?.fields?.custName !== "基准客户A")
+                throw new Error(`custName=${String(items?.[0]?.fields?.custName)}`);
+        });
+    });
+    // --- DYNAMIC cross-model backfill rule: declaration create -> project.latestPeriod ---
+    await runner.step("rule-save-dynamic", "rule.save", {
+        schemaCode: DECLARATION,
+        ruleCode: "Create",
+        name: "回填最近申报期",
+        nodeGraph: {
+            nodes: [
+                { nodeCode: "Start", nodeType: "START" },
+                {
+                    nodeCode: "UPDATE_1",
+                    nodeType: "UPDATE",
+                    targetObjectCode: PROJECT,
+                    inputParam: "_input",
+                    filterCondition: {
+                        mainConditions: [[{ targetSchemaDataItem: "id", ruleConditionType: "EQ", ruleValueType: "DYNAMIC", currentSchemaDataItem: "project" }]],
+                        sheetConditions: [],
+                    },
+                    dataActions: [{ targetDataItem: "latestPeriod", ruleValueType: "DYNAMIC", value: "", ruleActionType: "EQUALS", currentDataItemValue: "declarePeriod" }],
+                },
+                { nodeCode: "End", nodeType: "END" },
+            ],
+            routes: [{ preNode: "Start", postNode: "UPDATE_1" }, { preNode: "UPDATE_1", postNode: "End" }],
+        },
+    });
+    await runner.step("rule-enable-dynamic", "rule.enable", { schemaCode: DECLARATION, ruleCode: "Create" });
+    // The Create preset rule fires on the DRAFT→COMPLETED transition, so the
+    // declaration is saved, updated (readback normalisation), then submitted
+    // in place — data.save alone stays DRAFT and never triggers the rule.
+    const declaration = await runner.step("data-save-declaration", "data.save", {
+        schemaCode: DECLARATION,
+        formData: { declarePeriod: "202609", amount: 1000, project: { id: projectId } },
+    }, (result, check) => {
+        check("declaration row id returned", () => requireId(performField(result, "bizObjectId")));
+    });
+    const declarationId = performField(declaration, "bizObjectId");
+    await runner.step("data-update-declaration", "data.update", { schemaCode: DECLARATION, bizObjectId: declarationId, formData: { amount: 2000 } }, (result, check) => {
+        check("update readback carries the new amount", () => {
+            const value = result.readback?.authoritative?.amount;
+            if (value !== 2000)
+                throw new Error(`amount=${String(value)}`);
+        });
+    });
+    await runner.step("data-submit-declaration", "data.submit", {
+        schemaCode: DECLARATION,
+        bizObjectId: declarationId,
+        formData: { declarePeriod: "202609", amount: 2000, project: { id: projectId } },
+    }, (result, check) => {
+        check("declaration row COMPLETED", () => {
+            const status = readbackField(result, "sequenceStatus");
+            if (status !== "COMPLETED")
+                throw new Error(`sequenceStatus=${String(status)}`);
+        });
+    });
+    await runner.step("rule-backfill-readback", "data.load", { schemaCode: PROJECT, bizObjectId: projectId }, (result, check) => {
+        const period = result.data?.latestPeriod;
+        check("DYNAMIC rule backfilled latestPeriod", () => {
+            if (period !== "202609")
+                throw new Error(`latestPeriod=${String(period)}`);
+        });
+    });
+    // --- two-phase workflow approval: draft -> start submit -> approval todo -> COMPLETED ---
+    // Live-proven authoring shape (ticket 03 + 2026-09-12 probe): a bare
+    // template-less publish crashes the platform's saveDraftTemplate
+    // (cancelNotify copyProperties → 50000). Author = read the workflow's own
+    // draft, fill the empty approval participant, update, publish the FULL
+    // draft. The fake's minimal draft takes the same path.
+    await runner.step("workflow-create", "workflow.create", { schemaCode: DECLARATION, name: "申报审批", code: WORKFLOW });
+    const workflowDraft = await runner.step("workflow-draft-readback", "workflow.get_draft", { workflowCode: WORKFLOW, full: true });
+    const draftTemplate = (workflowDraft.data ?? { workflowCode: WORKFLOW });
+    const filledActivities = Array.isArray(draftTemplate.activities) && draftTemplate.activities.length > 0
+        ? draftTemplate.activities.map((activity) => activity.activityType === "PARTICIPANT" && !activity.participant ? { ...activity, participant: "{Originator}" } : activity)
+        : [
+            { activityCode: "Activity1", activityType: "START", activityName: "开始" },
+            { activityCode: "Activity2", activityType: "PARTICIPANT", activityName: "填写申请单", participant: "{Originator}" },
+            { activityCode: "Activity3", activityType: "PARTICIPANT", activityName: "审批", participant: "{Originator}" },
+            { activityCode: "Activity4", activityType: "END", activityName: "结束" },
+        ];
+    const workflowTemplate = { ...draftTemplate, activities: filledActivities };
+    await runner.step("workflow-update", "workflow.update", { schemaCode: DECLARATION, code: WORKFLOW, template: workflowTemplate });
+    await runner.step("workflow-publish", "workflow.publish", { schemaCode: DECLARATION, code: WORKFLOW, template: workflowTemplate }, (result, check) => {
+        check("workflow published", () => {
+            if (readbackField(result, "published") !== true)
+                throw new Error(`published=${String(readbackField(result, "published"))}`);
+        });
+    });
+    const draft = await runner.step("data-save-draft", "data.save", { schemaCode: DECLARATION, workflowCode: WORKFLOW, formData: { declarePeriod: "202610", amount: 3000, project: { id: projectId } } }, (result, check) => {
+        check("draft stays DRAFT", () => {
+            if (readbackField(result, "sequenceStatus") !== "DRAFT")
+                throw new Error(`sequenceStatus=${String(readbackField(result, "sequenceStatus"))}`);
+        });
+        check("start workItem present", () => requireId(performField(result, "workItemId")));
+    });
+    const bizObjectId = performField(draft, "bizObjectId");
+    const workItemId = performField(draft, "workItemId");
+    const workflowInstanceId = performField(draft, "workflowInstanceId");
+    await runner.step("data-submit-start", "data.submit", {
+        schemaCode: DECLARATION,
+        workItemId,
+        workflowInstanceId,
+        bizObjectId,
+        agree: true,
+        formData: { declarePeriod: "202610", amount: 3000, project: { id: projectId } },
+    }, (result, check) => {
+        check("same row id submitted", () => {
+            if (readbackField(result, "objectId") !== bizObjectId)
+                throw new Error("objectId changed");
+        });
+        check("row moved to PROCESSING", () => {
+            if (readbackField(result, "sequenceStatus") !== "PROCESSING")
+                throw new Error(`sequenceStatus=${String(readbackField(result, "sequenceStatus"))}`);
+        });
+    });
+    const todos = await runner.step("workitem-list", "workitem.list", { workflowInstanceId }, (result, check) => {
+        check("one approval todo pending", () => {
+            const items = result.items;
+            if (!items || items.length !== 1)
+                throw new Error(`todos=${items?.length ?? 0}`);
+        });
+    });
+    const approvalWorkItemId = workItemIdOf(todos.items?.[0]);
+    await runner.step("data-submit-approval", "data.submit", {
+        schemaCode: DECLARATION,
+        workItemId: approvalWorkItemId,
+        workflowInstanceId,
+        bizObjectId,
+        agree: true,
+        formData: { declarePeriod: "202610", amount: 3000, project: { id: projectId } },
+    }, (result, check) => {
+        check("row COMPLETED after approval", () => {
+            if (readbackField(result, "sequenceStatus") !== "COMPLETED")
+                throw new Error(`sequenceStatus=${String(readbackField(result, "sequenceStatus"))}`);
+        });
+    });
+    await runner.step("terminal-readback", "data.load", { schemaCode: DECLARATION, bizObjectId }, (result, check) => {
+        check("authoritative load shows COMPLETED", () => {
+            const status = result.data?.sequenceStatus;
+            if (status !== "COMPLETED")
+                throw new Error(`sequenceStatus=${String(status)}`);
+        });
+    });
+    if (live) {
+        // Live cleanup: model physical-delete cascade + absence readback. Runs
+        // even when aborted; excluded from metrics. Fixture codes are per-run
+        // nonces, so a slow or partially-orphaned cascade cannot block the next
+        // run (orphaned default data items are undeletable — 301012).
+        // Ticket 23: the order is dependency-inverted (d→p→c). Back-to-back
+        // deletes race the previous model's per-column async cascade (40-60s):
+        // live evidence shows the p/c deletes can come back refused
+        // (model-referenced-by while the relation columns still exist, or a
+        // transient wire-business envelope while the engine is busy) — wait and
+        // re-check instead of giving up; the deletes are idempotent
+        // (already-absent short-circuits), so retrying is always safe.
+        for (const code of [DECLARATION, PROJECT, CUSTOMER]) {
+            for (let attempt = 1; attempt <= 3; attempt += 1) {
+                // `{ schemaCode }` — model.delete's schema key. The original `{ code }`
+                // arg never reached the handler's schemaCode (no zod gate on the
+                // direct bench path), so every cleanup delete silently short-circuited
+                // as already-absent and left live fixtures behind (ticket 23).
+                const result = await runner.step(`cleanup-model-${code}${attempt > 1 ? `-retry-${attempt}` : ""}`, "model.delete", { schemaCode: code }, undefined, { cleanup: true });
+                const done = result.status === "ok" && result.readback?.absent === true;
+                const retryable = result.blocker === "model-referenced-by" ||
+                    result.blocker === "wire-business" ||
+                    result.status === "uncertain";
+                if (done || !retryable)
+                    break;
+                if (attempt < 3)
+                    await new Promise((resolve) => setTimeout(resolve, 45_000));
+            }
+        }
+        await runner.step("cleanup-absence-readback", "form.get", { schemaCode: DECLARATION }, (result, check) => {
+            check("default form absence after cascade", () => {
+                if (result.absent !== true && result.status !== "refused")
+                    throw new Error(`absent=${String(result.absent)} status=${String(result.status)}`);
+            });
+        }, { cleanup: true });
+    }
+    return { steps: runner.steps, aborted: runner.aborted };
+}
+//# sourceMappingURL=scenario.js.map

package/dist/bench/types.js

@@ -0,0 +1,76 @@
+/**
+ * Bench report shape — the five-dimension scoreboard consumed by the
+ * autonomy loop (`omc bench`). One run produces one BenchReport; the next
+ * run diffs against the stored previous report.
+ *
+ * Five dimensions (each must carry at least one machine-readable metric):
+ *   speed      — scenario wall clock
+ *   efficiency — wire call volume, duplicate targets, readback cache hits
+ *   quality    — scenario step pass rate + assertion pass rate
+ *   token      — response bytes + tools/list bytes, tokens ≈ bytes/4
+ *   intent     — golden-trajectory replay pass rate (live-verified sources only)
+ */
+/** Metric direction for delta verdicts — drives the autonomy loop's keep/revert decisions. */
+export const METRIC_DIRECTIONS = {
+    "speed.wallClockMs": "lower-is-better",
+    "efficiency.wireCalls": "lower-is-better",
+    "efficiency.duplicateWireCalls": "lower-is-better",
+    "efficiency.repeatReadbackTargets": "lower-is-better",
+    "efficiency.readbackCacheHits": "higher-is-better",
+    "quality.stepsOk": "higher-is-better",
+    "quality.assertionRate": "higher-is-better",
+    "token.responseBytes": "lower-is-better",
+    "token.toolsListBytes": "lower-is-better",
+    "token.estimatedTokens": "lower-is-better",
+    "intent.intentAccuracy": "higher-is-better",
+};
+/** Flatten the dimension tree into canonical metric keys ("speed.wallClockMs", …). */
+export function flattenMetrics(dimensions) {
+    return {
+        "speed.wallClockMs": Math.round(dimensions.speed.wallClockMs),
+        "speed.slowestStepMs": Math.round(dimensions.speed.slowestStepMs),
+        "efficiency.wireCalls": dimensions.efficiency.wireCalls,
+        "efficiency.uniqueWirePaths": dimensions.efficiency.uniqueWirePaths,
+        "efficiency.duplicateWireCalls": dimensions.efficiency.duplicateWireCalls,
+        "efficiency.repeatReadbackTargets": dimensions.efficiency.repeatReadbackTargets,
+        "efficiency.readbackCacheHits": dimensions.efficiency.readbackCacheHits,
+        "quality.stepsOk": dimensions.quality.stepsOk,
+        "quality.stepsTotal": dimensions.quality.stepsTotal,
+        "quality.assertionsPassed": dimensions.quality.assertionsPassed,
+        "quality.assertionsTotal": dimensions.quality.assertionsTotal,
+        "quality.assertionRate": round4(dimensions.quality.assertionRate),
+        "token.responseBytes": dimensions.token.responseBytes,
+        "token.toolsListBytes": dimensions.token.toolsListBytes,
+        "token.estimatedTokens": dimensions.token.estimatedTokens,
+        "intent.cases": dimensions.intent.cases,
+        "intent.passed": dimensions.intent.passed,
+        "intent.intentAccuracy": round4(dimensions.intent.intentAccuracy),
+    };
+}
+export function computeDelta(previous, current) {
+    const before = flattenMetrics(previous.dimensions);
+    const after = flattenMetrics(current.dimensions);
+    const delta = {};
+    for (const [key, value] of Object.entries(after)) {
+        const prior = before[key];
+        if (prior === undefined)
+            continue;
+        const direction = key in METRIC_DIRECTIONS ? METRIC_DIRECTIONS[key] : "neutral";
+        let changePct;
+        if (prior === 0)
+            changePct = value === 0 ? 0 : 1_000_000;
+        else
+            changePct = round4(((value - prior) / Math.abs(prior)) * 100);
+        let verdict = "same";
+        if (direction !== "neutral" && changePct !== 0) {
+            const gotBetter = direction === "lower-is-better" ? value < prior : value > prior;
+            verdict = gotBetter ? "improved" : "regressed";
+        }
+        delta[key] = { previous: prior, current: value, changePct, direction, verdict };
+    }
+    return delta;
+}
+function round4(value) {
+    return Math.round(value * 10000) / 10000;
+}
+//# sourceMappingURL=types.js.map

package/dist/bi-wire.js

@@ -0,0 +1,41 @@
+import { CloudPivotRequestTimeoutError } from "./session.js";
+import { WireError } from "./wire.js";
+/**
+ * Drive one BI call and return its decoded `data`. Failures raise `WireError`
+ * so the governed read/write pipelines classify them exactly like platform
+ * envelope failures: a transport/timeout failure is UNCERTAIN (freeze, never
+ * assume success), a BI `errorCode` is a definitive business refusal.
+ */
+export async function biCall(session, call) {
+    const body = {
+        ...(call.body ?? {}),
+        corpId: call.auth.corpId,
+        config: { token: session.token(), reportCode: call.auth.reportCode, appCode: call.auth.appCode },
+    };
+    const response = await session
+        .request({
+        path: call.path,
+        method: call.method ?? "POST",
+        ...(call.query ? { query: call.query } : {}),
+        body,
+    })
+        .catch((error) => {
+        if (error instanceof CloudPivotRequestTimeoutError)
+            throw new WireError("transport", error.message);
+        throw error;
+    });
+    if (response.status < 200 || response.status >= 300)
+        throw new WireError("http-status", `HTTP ${response.status} for BI ${call.path}`, undefined, { httpStatus: response.status });
+    const envelope = response.body;
+    if (!envelope || typeof envelope !== "object")
+        throw new WireError("malformed-envelope", `non-object BI envelope for ${call.path}`);
+    const record = envelope;
+    if (record.errorCode !== undefined && record.errorCode !== null && record.errorCode !== "")
+        throw new WireError("business", `BI ${call.path} rejected: ${String(record.errorMessage ?? record.errorCode)} [${String(record.errorCode)}]`);
+    if (!("data" in record))
+        throw new WireError("malformed-envelope", `BI ${call.path} returned no data field`);
+    return record.data;
+}
+/** Default BI corp id observed on the aozhe tenant; overridable per call. */
+export const DEFAULT_BI_CORP_ID = "a";
+//# sourceMappingURL=bi-wire.js.map