@bolloon/bolloon-agent 0.3.30 → 0.3.32

package/dist/constraint-runtime/constraint/budget.js

@@ -0,0 +1,22 @@
+export class BudgetTracker {
+    maxBudgetTokens;
+    maxTurns;
+    compactAfterTurns;
+    constructor(maxBudgetTokens = 2000, maxTurns = 8, compactAfterTurns = 12) {
+        this.maxBudgetTokens = maxBudgetTokens;
+        this.maxTurns = maxTurns;
+        this.compactAfterTurns = compactAfterTurns;
+    }
+    addTurn(inputTokens, outputTokens) {
+        return { inputTokens, outputTokens };
+    }
+    isBudgetExceeded(usage) {
+        return usage.inputTokens + usage.outputTokens > this.maxBudgetTokens;
+    }
+    isTurnLimitExceeded(currentTurns) {
+        return currentTurns >= this.maxTurns;
+    }
+    shouldCompact(turnCount) {
+        return turnCount > this.compactAfterTurns;
+    }
+}

package/dist/constraint-runtime/constraint/index.d.ts

@@ -0,0 +1,3 @@
+export { ToolPermissionContext } from './permission.js';
+export { BudgetTracker } from './budget.js';
+export type { UsageSummary } from '../models.js';

package/dist/constraint-runtime/constraint/index.js

@@ -0,0 +1,2 @@
+export { ToolPermissionContext } from './permission.js';
+export { BudgetTracker } from './budget.js';

package/dist/constraint-runtime/constraint/permission.d.ts

@@ -0,0 +1,9 @@
+import { PermissionDenial } from '../models.js';
+export declare class ToolPermissionContext {
+    private denyTools;
+    private denyPrefixes;
+    private constructor();
+    static fromIterables(denyTools?: string[], denyPrefixes?: string[]): ToolPermissionContext;
+    blocks(name: string): boolean;
+    createDenial(toolName: string, reason: string): PermissionDenial;
+}

package/dist/constraint-runtime/constraint/permission.js

@@ -0,0 +1,20 @@
+export class ToolPermissionContext {
+    denyTools;
+    denyPrefixes;
+    constructor(denyTools, denyPrefixes) {
+        this.denyTools = denyTools;
+        this.denyPrefixes = denyPrefixes;
+    }
+    static fromIterables(denyTools = [], denyPrefixes = []) {
+        return new ToolPermissionContext(new Set(denyTools.map(t => t.toLowerCase())), denyPrefixes);
+    }
+    blocks(name) {
+        const lower = name.toLowerCase();
+        if (this.denyTools.has(lower))
+            return true;
+        return this.denyPrefixes.some(p => lower.startsWith(p.toLowerCase()));
+    }
+    createDenial(toolName, reason) {
+        return { toolName, reason };
+    }
+}

package/dist/constraint-runtime/context.d.ts

@@ -0,0 +1,12 @@
+export interface PortContext {
+    sourceRoot: string;
+    testsRoot: string;
+    assetsRoot: string;
+    archiveRoot: string;
+    pythonFileCount: number;
+    testFileCount: number;
+    assetFileCount: number;
+    archiveAvailable: boolean;
+}
+export declare function buildPortContext(base?: string): PortContext;
+export declare function renderContext(context: PortContext): string;

package/dist/constraint-runtime/context.js

@@ -0,0 +1,30 @@
+import * as path from 'path';
+import { fileURLToPath } from 'url';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+export function buildPortContext(base) {
+    const root = base || __dirname;
+    const srcRoot = path.join(root, 'src');
+    const testsRoot = path.join(root, 'tests');
+    const assetsRoot = path.join(root, 'assets');
+    const archiveRoot = path.join(root, 'archive');
+    return {
+        sourceRoot: srcRoot,
+        testsRoot: testsRoot,
+        assetsRoot: assetsRoot,
+        archiveRoot: archiveRoot,
+        pythonFileCount: 0,
+        testFileCount: 0,
+        assetFileCount: 0,
+        archiveAvailable: false,
+    };
+}
+export function renderContext(context) {
+    return [
+        `Source root: ${context.sourceRoot}`,
+        `Test root: ${context.testsRoot}`,
+        `Assets root: ${context.assetsRoot}`,
+        `Archive root: ${context.archiveRoot}`,
+        `Archive available: ${context.archiveAvailable}`,
+    ].join('\n');
+}

package/dist/constraint-runtime/coordinator/index.d.ts

@@ -0,0 +1,11 @@
+export declare const ARCHIVE_NAME: string;
+export declare const MODULE_COUNT: number;
+export declare const SAMPLE_FILES: string[];
+export declare const PORTING_NOTE: string;
+declare const _default: {
+    ARCHIVE_NAME: string;
+    MODULE_COUNT: number;
+    PORTING_NOTE: string;
+    SAMPLE_FILES: string[];
+};
+export default _default;

package/dist/constraint-runtime/coordinator/index.js

@@ -0,0 +1,12 @@
+import { loadArchiveMetadata } from '../_archive_helper.js';
+const SNAPSHOT = loadArchiveMetadata('coordinator');
+export const ARCHIVE_NAME = SNAPSHOT['archive_name'];
+export const MODULE_COUNT = SNAPSHOT['module_count'];
+export const SAMPLE_FILES = SNAPSHOT['sample_files'];
+export const PORTING_NOTE = `Python placeholder package for '${ARCHIVE_NAME}' with ${MODULE_COUNT} archived module references.`;
+export default {
+    ARCHIVE_NAME,
+    MODULE_COUNT,
+    PORTING_NOTE,
+    SAMPLE_FILES,
+};

package/dist/constraint-runtime/cost_hook.d.ts

@@ -0,0 +1,2 @@
+import { CostTracker } from './cost_tracker.js';
+export declare function applyCostHook(tracker: CostTracker, label: string, units: number): CostTracker;

package/dist/constraint-runtime/cost_hook.js

@@ -0,0 +1,4 @@
+export function applyCostHook(tracker, label, units) {
+    tracker.record(label, units);
+    return tracker;
+}

package/dist/constraint-runtime/cost_tracker.d.ts

@@ -0,0 +1,5 @@
+export declare class CostTracker {
+    totalUnits: number;
+    events: string[];
+    record(label: string, units: number): void;
+}

package/dist/constraint-runtime/cost_tracker.js

@@ -0,0 +1,8 @@
+export class CostTracker {
+    totalUnits = 0;
+    events = [];
+    record(label, units) {
+        this.totalUnits += units;
+        this.events.push(`${label}:${units}`);
+    }
+}

package/dist/constraint-runtime/deferred_init.d.ts

@@ -0,0 +1,8 @@
+export interface DeferredInitResult {
+    trusted: boolean;
+    pluginInit: boolean;
+    skillInit: boolean;
+    mcpPrefetch: boolean;
+    sessionHooks: boolean;
+}
+export declare function runDeferredInit(trusted: boolean): DeferredInitResult;

package/dist/constraint-runtime/deferred_init.js

@@ -0,0 +1,10 @@
+export function runDeferredInit(trusted) {
+    const enabled = Boolean(trusted);
+    return {
+        trusted,
+        pluginInit: enabled,
+        skillInit: enabled,
+        mcpPrefetch: enabled,
+        sessionHooks: enabled,
+    };
+}

package/dist/constraint-runtime/direct_modes.d.ts

@@ -0,0 +1,7 @@
+export interface DirectModeReport {
+    mode: string;
+    target: string;
+    active: boolean;
+}
+export declare function runDirectConnect(target: string): DirectModeReport;
+export declare function runDeepLink(target: string): DirectModeReport;

package/dist/constraint-runtime/direct_modes.js

@@ -0,0 +1,6 @@
+export function runDirectConnect(target) {
+    return { mode: 'direct-connect', target, active: true };
+}
+export function runDeepLink(target) {
+    return { mode: 'deep-link', target, active: true };
+}

package/dist/constraint-runtime/dynamic-tool-loader.d.ts

@@ -0,0 +1,13 @@
+export interface ToolResult {
+    success: boolean;
+    data?: any;
+    error?: string;
+}
+export interface ToolExecutor {
+    loadAndExecute(modulePath: string, functionName: string, params: any): Promise<ToolResult>;
+}
+export declare function executeToolFromSnapshot(sourceHint: string, params: any): Promise<ToolResult>;
+export declare class DynamicToolExecutor implements ToolExecutor {
+    loadAndExecute(modulePath: string, functionName: string, params: any): Promise<ToolResult>;
+}
+export declare const defaultExecutor: DynamicToolExecutor;

package/dist/constraint-runtime/dynamic-tool-loader.js

@@ -0,0 +1,85 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { fileURLToPath } from 'url';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+function resolveToolPath(sourceHint) {
+    return path.join(__dirname, sourceHint);
+}
+function inferFunctionName(sourceHint) {
+    const basename = path.basename(sourceHint, path.extname(sourceHint));
+    const nameMap = {
+        listMarkets: 'listMarkets',
+        getMarket: 'getMarket',
+        createOrder: 'createOrder',
+        cancelOrder: 'cancelOrder',
+        getOrders: 'getOrders',
+        createTransaction: 'createTransaction',
+        proposeTransaction: 'proposeTransaction',
+        confirmTransaction: 'confirmTransaction',
+        executeTransaction: 'executeTransaction',
+        getPendingTransactions: 'getPendingTransactions',
+        getBalance: 'getBalance',
+        deploySafe: 'deploySafe',
+        runCommand: 'runCommand',
+        listAdapters: 'listAdapters',
+        execAdapter: 'execAdapter',
+    };
+    return nameMap[basename] || basename;
+}
+export async function executeToolFromSnapshot(sourceHint, params) {
+    try {
+        const fullPath = resolveToolPath(sourceHint);
+        if (!fs.existsSync(fullPath)) {
+            return {
+                success: false,
+                error: `Tool file not found: ${fullPath}`,
+            };
+        }
+        const module = await import(`file://${fullPath}?t=${Date.now()}`);
+        const functionName = inferFunctionName(sourceHint);
+        if (typeof module[functionName] !== 'function') {
+            return {
+                success: false,
+                error: `Function '${functionName}' not found in ${sourceHint}`,
+            };
+        }
+        const result = await module[functionName](params);
+        return {
+            success: true,
+            data: result,
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+export class DynamicToolExecutor {
+    async loadAndExecute(modulePath, functionName, params) {
+        try {
+            const fullPath = resolveToolPath(modulePath);
+            if (!fs.existsSync(fullPath)) {
+                return { success: false, error: `Module not found: ${fullPath}` };
+            }
+            const module = await import(`file://${fullPath}?t=${Date.now()}`);
+            if (typeof module[functionName] !== 'function') {
+                return {
+                    success: false,
+                    error: `Function '${functionName}' not exported from ${modulePath}`,
+                };
+            }
+            const result = await module[functionName](params);
+            return { success: true, data: result };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : String(error),
+            };
+        }
+    }
+}
+export const defaultExecutor = new DynamicToolExecutor();

package/dist/constraint-runtime/entrypoints/index.d.ts

@@ -0,0 +1,11 @@
+export declare const ARCHIVE_NAME: string;
+export declare const MODULE_COUNT: number;
+export declare const SAMPLE_FILES: string[];
+export declare const PORTING_NOTE: string;
+declare const _default: {
+    ARCHIVE_NAME: string;
+    MODULE_COUNT: number;
+    PORTING_NOTE: string;
+    SAMPLE_FILES: string[];
+};
+export default _default;

package/dist/constraint-runtime/entrypoints/index.js

@@ -0,0 +1,12 @@
+import { loadArchiveMetadata } from '../_archive_helper.js';
+const SNAPSHOT = loadArchiveMetadata('entrypoints');
+export const ARCHIVE_NAME = SNAPSHOT['archive_name'];
+export const MODULE_COUNT = SNAPSHOT['module_count'];
+export const SAMPLE_FILES = SNAPSHOT['sample_files'];
+export const PORTING_NOTE = `Python placeholder package for '${ARCHIVE_NAME}' with ${MODULE_COUNT} archived module references.`;
+export default {
+    ARCHIVE_NAME,
+    MODULE_COUNT,
+    PORTING_NOTE,
+    SAMPLE_FILES,
+};

package/dist/constraint-runtime/execution_registry.d.ts

@@ -0,0 +1,20 @@
+export declare class MirroredCommand {
+    name: string;
+    sourceHint: string;
+    constructor(name: string, sourceHint: string);
+    execute(prompt: string): string;
+}
+export declare class MirroredTool {
+    name: string;
+    sourceHint: string;
+    constructor(name: string, sourceHint: string);
+    execute(payload: string): Promise<string>;
+}
+export declare class ExecutionRegistry {
+    commands: MirroredCommand[];
+    tools: MirroredTool[];
+    constructor(commands: MirroredCommand[], tools: MirroredTool[]);
+    command(name: string): MirroredCommand | undefined;
+    tool(name: string): MirroredTool | undefined;
+}
+export declare function buildExecutionRegistry(): ExecutionRegistry;

package/dist/constraint-runtime/execution_registry.js

@@ -0,0 +1,44 @@
+import { PORTED_COMMANDS, executeCommand } from './commands.js';
+import { PORTED_TOOLS, executeTool } from './tools.js';
+export class MirroredCommand {
+    name;
+    sourceHint;
+    constructor(name, sourceHint) {
+        this.name = name;
+        this.sourceHint = sourceHint;
+    }
+    execute(prompt) {
+        return executeCommand(this.name, prompt).message;
+    }
+}
+export class MirroredTool {
+    name;
+    sourceHint;
+    constructor(name, sourceHint) {
+        this.name = name;
+        this.sourceHint = sourceHint;
+    }
+    async execute(payload) {
+        const result = await executeTool(this.name, payload);
+        return result.message;
+    }
+}
+export class ExecutionRegistry {
+    commands;
+    tools;
+    constructor(commands, tools) {
+        this.commands = commands;
+        this.tools = tools;
+    }
+    command(name) {
+        const lowered = name.toLowerCase();
+        return this.commands.find(c => c.name.toLowerCase() === lowered);
+    }
+    tool(name) {
+        const lowered = name.toLowerCase();
+        return this.tools.find(t => t.name.toLowerCase() === lowered);
+    }
+}
+export function buildExecutionRegistry() {
+    return new ExecutionRegistry(PORTED_COMMANDS.map(m => new MirroredCommand(m.name, m.sourceHint)), PORTED_TOOLS.map(m => new MirroredTool(m.name, m.sourceHint)));
+}

package/dist/constraint-runtime/history.d.ts

@@ -0,0 +1,9 @@
+export interface HistoryEvent {
+    title: string;
+    detail: string;
+}
+export declare class HistoryLog {
+    events: HistoryEvent[];
+    add(title: string, detail: string): void;
+    asMarkdown(): string;
+}

package/dist/constraint-runtime/history.js

@@ -0,0 +1,9 @@
+export class HistoryLog {
+    events = [];
+    add(title, detail) {
+        this.events.push({ title, detail });
+    }
+    asMarkdown() {
+        return ['# Session History', '', ...this.events.map(e => `- ${e.title}: ${e.detail}`)].join('\n');
+    }
+}

package/dist/constraint-runtime/hooks/index.d.ts

@@ -0,0 +1,11 @@
+export declare const ARCHIVE_NAME: string;
+export declare const MODULE_COUNT: number;
+export declare const SAMPLE_FILES: string[];
+export declare const PORTING_NOTE: string;
+declare const _default: {
+    ARCHIVE_NAME: string;
+    MODULE_COUNT: number;
+    PORTING_NOTE: string;
+    SAMPLE_FILES: string[];
+};
+export default _default;

package/dist/constraint-runtime/hooks/index.js

@@ -0,0 +1,12 @@
+import { loadArchiveMetadata } from '../_archive_helper.js';
+const SNAPSHOT = loadArchiveMetadata('hooks');
+export const ARCHIVE_NAME = SNAPSHOT['archive_name'];
+export const MODULE_COUNT = SNAPSHOT['module_count'];
+export const SAMPLE_FILES = SNAPSHOT['sample_files'];
+export const PORTING_NOTE = `Python placeholder package for '${ARCHIVE_NAME}' with ${MODULE_COUNT} archived module references.`;
+export default {
+    ARCHIVE_NAME,
+    MODULE_COUNT,
+    PORTING_NOTE,
+    SAMPLE_FILES,
+};

package/dist/constraint-runtime/index.d.ts

@@ -0,0 +1,26 @@
+export * from './constraint/index.js';
+export * from './thinking/index.js';
+export * from './agent/index.js';
+export * from './skills/index.js';
+export * from './runtime/index.js';
+export { ToolPermissionContext } from './constraint/permission.js';
+export { BudgetTracker } from './constraint/budget.js';
+export { DeepThinkingEngine, type ThinkResult, type ThinkStep } from './thinking/engine.js';
+export { AgentCoordinator, type SubTask, type AgentResult } from './agent/coordinator.js';
+export { SkillRegistry, type Skill } from './skills/skill-registry.js';
+export { Session, type RuntimeSession } from './runtime/session.js';
+export * from './models.js';
+export { HistoryLog, type HistoryEvent } from './history.js';
+export { TranscriptStore } from './transcript.js';
+export { CostTracker } from './cost_tracker.js';
+export { buildSetup, runSetup, type SetupReport, type WorkspaceSetup } from './setup.js';
+export { buildPortContext, type PortContext } from './context.js';
+export { buildCommandGraph } from './command_graph.js';
+export { buildBootstrapGraph } from './bootstrap_graph.js';
+export { runParityAudit, type ParityAuditResult } from './parity_audit.js';
+export { runRemoteMode, runSshMode, runTeleportMode, type RuntimeModeReport } from './remote_runtime.js';
+export { runDirectConnect, runDeepLink, type DirectModeReport } from './direct_modes.js';
+export { assembleToolPool, type ToolPool } from './tool_pool.js';
+export { saveSession, loadSession, type StoredSession } from './session_store.js';
+export declare const VERSION = "0.1.0";
+export declare const NAME = "@bolloon/constraint-runtime";

package/dist/constraint-runtime/index.js

@@ -0,0 +1,26 @@
+export * from './constraint/index.js';
+export * from './thinking/index.js';
+export * from './agent/index.js';
+export * from './skills/index.js';
+export * from './runtime/index.js';
+export { ToolPermissionContext } from './constraint/permission.js';
+export { BudgetTracker } from './constraint/budget.js';
+export { DeepThinkingEngine } from './thinking/engine.js';
+export { AgentCoordinator } from './agent/coordinator.js';
+export { SkillRegistry } from './skills/skill-registry.js';
+export { Session } from './runtime/session.js';
+export * from './models.js';
+export { HistoryLog } from './history.js';
+export { TranscriptStore } from './transcript.js';
+export { CostTracker } from './cost_tracker.js';
+export { buildSetup, runSetup } from './setup.js';
+export { buildPortContext } from './context.js';
+export { buildCommandGraph } from './command_graph.js';
+export { buildBootstrapGraph } from './bootstrap_graph.js';
+export { runParityAudit } from './parity_audit.js';
+export { runRemoteMode, runSshMode, runTeleportMode } from './remote_runtime.js';
+export { runDirectConnect, runDeepLink } from './direct_modes.js';
+export { assembleToolPool } from './tool_pool.js';
+export { saveSession, loadSession } from './session_store.js';
+export const VERSION = '0.1.0';
+export const NAME = '@bolloon/constraint-runtime';

package/dist/constraint-runtime/ink.d.ts

@@ -0,0 +1 @@
+export declare function renderMarkdownPanel(text: string): string;

package/dist/constraint-runtime/ink.js

@@ -0,0 +1,4 @@
+export function renderMarkdownPanel(text) {
+    const border = '='.repeat(40);
+    return `${border}\n${text}\n${border}`;
+}

package/dist/constraint-runtime/keybindings/index.d.ts

@@ -0,0 +1,11 @@
+export declare const ARCHIVE_NAME: string;
+export declare const MODULE_COUNT: number;
+export declare const SAMPLE_FILES: string[];
+export declare const PORTING_NOTE: string;
+declare const _default: {
+    ARCHIVE_NAME: string;
+    MODULE_COUNT: number;
+    PORTING_NOTE: string;
+    SAMPLE_FILES: string[];
+};
+export default _default;

package/dist/constraint-runtime/keybindings/index.js

@@ -0,0 +1,12 @@
+import { loadArchiveMetadata } from '../_archive_helper.js';
+const SNAPSHOT = loadArchiveMetadata('keybindings');
+export const ARCHIVE_NAME = SNAPSHOT['archive_name'];
+export const MODULE_COUNT = SNAPSHOT['module_count'];
+export const SAMPLE_FILES = SNAPSHOT['sample_files'];
+export const PORTING_NOTE = `Python placeholder package for '${ARCHIVE_NAME}' with ${MODULE_COUNT} archived module references.`;
+export default {
+    ARCHIVE_NAME,
+    MODULE_COUNT,
+    PORTING_NOTE,
+    SAMPLE_FILES,
+};

package/dist/constraint-runtime/memdir/index.d.ts

@@ -0,0 +1,11 @@
+export declare const ARCHIVE_NAME: string;
+export declare const MODULE_COUNT: number;
+export declare const SAMPLE_FILES: string[];
+export declare const PORTING_NOTE: string;
+declare const _default: {
+    ARCHIVE_NAME: string;
+    MODULE_COUNT: number;
+    PORTING_NOTE: string;
+    SAMPLE_FILES: string[];
+};
+export default _default;

package/dist/constraint-runtime/memdir/index.js

@@ -0,0 +1,12 @@
+import { loadArchiveMetadata } from '../_archive_helper.js';
+const SNAPSHOT = loadArchiveMetadata('memdir');
+export const ARCHIVE_NAME = SNAPSHOT['archive_name'];
+export const MODULE_COUNT = SNAPSHOT['module_count'];
+export const SAMPLE_FILES = SNAPSHOT['sample_files'];
+export const PORTING_NOTE = `Python placeholder package for '${ARCHIVE_NAME}' with ${MODULE_COUNT} archived module references.`;
+export default {
+    ARCHIVE_NAME,
+    MODULE_COUNT,
+    PORTING_NOTE,
+    SAMPLE_FILES,
+};

package/dist/constraint-runtime/migrations/index.d.ts

@@ -0,0 +1,11 @@
+export declare const ARCHIVE_NAME: string;
+export declare const MODULE_COUNT: number;
+export declare const SAMPLE_FILES: string[];
+export declare const PORTING_NOTE: string;
+declare const _default: {
+    ARCHIVE_NAME: string;
+    MODULE_COUNT: number;
+    PORTING_NOTE: string;
+    SAMPLE_FILES: string[];
+};
+export default _default;

package/dist/constraint-runtime/migrations/index.js

@@ -0,0 +1,12 @@
+import { loadArchiveMetadata } from '../_archive_helper.js';
+const SNAPSHOT = loadArchiveMetadata('migrations');
+export const ARCHIVE_NAME = SNAPSHOT['archive_name'];
+export const MODULE_COUNT = SNAPSHOT['module_count'];
+export const SAMPLE_FILES = SNAPSHOT['sample_files'];
+export const PORTING_NOTE = `Python placeholder package for '${ARCHIVE_NAME}' with ${MODULE_COUNT} archived module references.`;
+export default {
+    ARCHIVE_NAME,
+    MODULE_COUNT,
+    PORTING_NOTE,
+    SAMPLE_FILES,
+};

package/dist/constraint-runtime/models.d.ts

@@ -0,0 +1,42 @@
+export interface PortingModule {
+    name: string;
+    responsibility: string;
+    sourceHint: string;
+    status: PortingStatus;
+    readonly _jsonName?: string;
+}
+export interface Subsystem {
+    name: string;
+    path: string;
+    fileCount: number;
+    notes: string;
+}
+export interface PermissionDenial {
+    toolName: string;
+    reason: string;
+}
+export interface UsageSummary {
+    inputTokens: number;
+    outputTokens: number;
+}
+export interface TurnResult {
+    prompt: string;
+    output: string;
+    matchedCommands: string[];
+    matchedTools: string[];
+    permissionDenials: PermissionDenial[];
+    usage: UsageSummary;
+    stopReason: string;
+}
+export interface RoutedMatch {
+    kind: 'command' | 'tool';
+    name: string;
+    sourceHint: string;
+    score: number;
+}
+export type PortingStatus = 'mirrored' | 'ported' | 'pending';
+export interface PortingBacklog {
+    title: string;
+    modules: PortingModule[];
+    summaryLines(): string[];
+}

package/dist/constraint-runtime/models.js

@@ -0,0 +1 @@
+export {};

package/dist/constraint-runtime/moreright/index.d.ts

@@ -0,0 +1,11 @@
+export declare const ARCHIVE_NAME: string;
+export declare const MODULE_COUNT: number;
+export declare const SAMPLE_FILES: string[];
+export declare const PORTING_NOTE: string;
+declare const _default: {
+    ARCHIVE_NAME: string;
+    MODULE_COUNT: number;
+    PORTING_NOTE: string;
+    SAMPLE_FILES: string[];
+};
+export default _default;