zeropoint-node 1.0.1 → 1.0.3

package/dist/core/ZeroPointSystem.js

@@ -1,343 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ZeroPointSystem = void 0;
-const DimensionRegistry_1 = require("./DimensionRegistry");
-const KnowledgeRegistry_1 = require("./KnowledgeRegistry");
-const applyLaws_1 = require("./applyLaws");
-/**
- * Unified ZeroPoint System
- * Provides DRY access to all knowledge across dimensions
- */
-class ZeroPointSystem {
-    constructor() {
-        this.isInitialized = false;
-        this.dimensionRegistry = new DimensionRegistry_1.DimensionRegistry();
-        this.knowledgeRegistry = new KnowledgeRegistry_1.KnowledgeRegistry();
-    }
-    /**
-     * Initialize the system with all dimensions and knowledge units
-     */
-    async initialize() {
-        if (this.isInitialized)
-            return;
-        // Register all dimensions
-        await this.registerAllDimensions();
-        // Register all knowledge units
-        await this.registerAllKnowledge();
-        // Apply metaphysical laws to all knowledge units
-        await this.applyLawsToAll();
-        this.isInitialized = true;
-    }
-    /**
-     * Register all dimensions in the system
-     */
-    async registerAllDimensions() {
-        // 1D Dimensions
-        this.registerDimension({
-            name: 'point',
-            type: 'geometric',
-            complexity: 1,
-            isActive: true,
-            parent: null,
-            dependencies: [],
-            compatibleDimensions: ['line', 'plane', 'space'],
-            supportedOperations: ['create', 'transform', 'observe'],
-            description: 'Zero-dimensional point of infinite potential'
-        });
-        this.registerDimension({
-            name: 'line',
-            type: 'geometric',
-            complexity: 2,
-            isActive: true,
-            parent: 'point',
-            dependencies: ['point'],
-            compatibleDimensions: ['point', 'plane', 'space'],
-            supportedOperations: ['create', 'transform', 'observe', 'extend'],
-            description: 'One-dimensional line connecting points'
-        });
-        // 2D Dimensions
-        this.registerDimension({
-            name: 'plane',
-            type: 'geometric',
-            complexity: 3,
-            isActive: true,
-            parent: 'line',
-            dependencies: ['line'],
-            compatibleDimensions: ['point', 'line', 'space'],
-            supportedOperations: ['create', 'transform', 'observe', 'extend', 'rotate'],
-            description: 'Two-dimensional plane of manifestation'
-        });
-        // 3D Dimensions
-        this.registerDimension({
-            name: 'space',
-            type: 'geometric',
-            complexity: 4,
-            isActive: true,
-            parent: 'plane',
-            dependencies: ['plane'],
-            compatibleDimensions: ['point', 'line', 'plane', 'time'],
-            supportedOperations: ['create', 'transform', 'observe', 'extend', 'rotate', 'translate'],
-            description: 'Three-dimensional space of physical reality'
-        });
-        // 4D Dimensions
-        this.registerDimension({
-            name: 'time',
-            type: 'temporal',
-            complexity: 5,
-            isActive: true,
-            parent: 'space',
-            dependencies: ['space'],
-            compatibleDimensions: ['space', 'consciousness'],
-            supportedOperations: ['create', 'transform', 'observe', 'flow', 'reverse'],
-            description: 'Fourth dimension of temporal flow'
-        });
-        // Consciousness Dimensions
-        this.registerDimension({
-            name: 'consciousness',
-            type: 'metaphysical',
-            complexity: 6,
-            isActive: true,
-            parent: 'time',
-            dependencies: ['time'],
-            compatibleDimensions: ['time', 'void'],
-            supportedOperations: ['create', 'transform', 'observe', 'flow', 'evolve', 'unify'],
-            description: 'Dimension of conscious awareness and evolution'
-        });
-        // Void Dimensions
-        this.registerDimension({
-            name: 'void',
-            type: 'metaphysical',
-            complexity: 7,
-            isActive: true,
-            parent: 'consciousness',
-            dependencies: ['consciousness'],
-            compatibleDimensions: ['consciousness', 'unity'],
-            supportedOperations: ['create', 'transform', 'observe', 'unify', 'resolve'],
-            description: 'Infinite potential and source of all creation'
-        });
-        // Unity Dimensions
-        this.registerDimension({
-            name: 'unity',
-            type: 'metaphysical',
-            complexity: 8,
-            isActive: true,
-            parent: 'void',
-            dependencies: ['void'],
-            compatibleDimensions: ['void'],
-            supportedOperations: ['create', 'transform', 'observe', 'unify', 'resolve', 'transcend'],
-            description: 'Ultimate unity where all dimensions converge'
-        });
-    }
-    /**
-     * Register all knowledge units in the system
-     */
-    async registerAllKnowledge() {
-        // Import and register all existing knowledge units
-        const { ConsciousnessField } = await Promise.resolve().then(() => __importStar(require('../consciousness/ConsciousnessField')));
-        const { VortexMath } = await Promise.resolve().then(() => __importStar(require('../math/VortexMath')));
-        const { SacredGeometryRegistry } = await Promise.resolve().then(() => __importStar(require('../patterns/SacredGeometryRegistry')));
-        const { MetaphysicalLawRegistry } = await Promise.resolve().then(() => __importStar(require('../laws/MetaphysicalLawRegistry')));
-        // Register consciousness fields
-        this.registerKnowledgeUnit(new ConsciousnessField(), 'consciousness');
-        // Register mathematical systems
-        this.registerKnowledgeUnit(new VortexMath(), 'space');
-        // Register sacred geometry patterns
-        const sacredGeometry = new SacredGeometryRegistry();
-        for (const pattern of sacredGeometry.getAllPatterns()) {
-            this.registerKnowledgeUnit(pattern, 'plane');
-        }
-        // Register metaphysical laws
-        const laws = MetaphysicalLawRegistry.getAllLaws();
-        for (const law of laws) {
-            this.registerKnowledgeUnit(law, 'unity');
-        }
-        // Add void dimension knowledge units
-        const voidField = {
-            name: 'VoidField',
-            type: 'Field',
-            dimension: 'void',
-            complexity: 5,
-            isActive: true,
-            supportedOperations: ['create', 'transform', 'observe', 'unify'],
-            tags: ['void', 'field', 'metaphysical']
-        };
-        this.registerKnowledgeUnit(voidField, 'void');
-        // Add line dimension knowledge units
-        const linePattern = {
-            name: 'LinePattern',
-            type: 'Pattern',
-            dimension: 'line',
-            complexity: 1,
-            isActive: true,
-            supportedOperations: ['create', 'transform', 'observe'],
-            tags: ['line', 'pattern', 'geometric']
-        };
-        this.registerKnowledgeUnit(linePattern, 'line');
-    }
-    /**
-     * Apply metaphysical laws to all knowledge units
-     */
-    async applyLawsToAll() {
-        const allUnits = this.knowledgeRegistry.getAll();
-        // Only include objects that have an apply function and description
-        const laws = this.knowledgeRegistry.getByType('MetaphysicalLaw').filter((law) => typeof law.apply === 'function' && 'description' in law);
-        for (const unit of allUnits) {
-            for (const law of laws) {
-                (0, applyLaws_1.applyLaws)(unit, [law]);
-            }
-        }
-    }
-    /**
-     * Register a dimension
-     */
-    registerDimension(dimension) {
-        this.dimensionRegistry.register(dimension);
-    }
-    /**
-     * Register a knowledge unit
-     */
-    registerKnowledgeUnit(unit, dimension) {
-        this.knowledgeRegistry.register(unit, dimension);
-    }
-    /**
-     * Get knowledge units by dimension
-     */
-    getKnowledgeByDimension(dimension) {
-        return this.knowledgeRegistry.getByDimension(dimension);
-    }
-    /**
-     * Get knowledge units by type
-     */
-    getKnowledgeByType(type) {
-        return this.knowledgeRegistry.getByType(type);
-    }
-    /**
-     * Get knowledge units by criteria
-     */
-    getKnowledgeByCriteria(criteria) {
-        return this.knowledgeRegistry.getByCriteria(criteria);
-    }
-    /**
-     * Get compatible knowledge units
-     */
-    getCompatibleKnowledge(unitName) {
-        return this.knowledgeRegistry.getCompatibleUnits(unitName);
-    }
-    /**
-     * Get dimensions by type
-     */
-    getDimensionsByType(type) {
-        return this.dimensionRegistry.getByType(type);
-    }
-    /**
-     * Get active dimensions
-     */
-    getActiveDimensions() {
-        return this.dimensionRegistry.getActiveDimensions();
-    }
-    /**
-     * Get knowledge units that support an operation
-     */
-    getKnowledgeByOperation(operation) {
-        return this.knowledgeRegistry.getBySupportedOperation(operation);
-    }
-    /**
-     * Get dimensions that support an operation
-     */
-    getDimensionsByOperation(operation) {
-        return this.dimensionRegistry.getBySupportedOperation(operation);
-    }
-    /**
-     * Activate a dimension and its knowledge
-     */
-    activateDimension(name) {
-        this.dimensionRegistry.activateDimension(name);
-        // Activate all knowledge units in this dimension
-        const knowledgeUnits = this.getKnowledgeByDimension(name);
-        for (const unit of knowledgeUnits) {
-            this.knowledgeRegistry.activateUnit(this.getUnitName(unit));
-        }
-    }
-    /**
-     * Deactivate a dimension and its knowledge
-     */
-    deactivateDimension(name) {
-        this.dimensionRegistry.deactivateDimension(name);
-        // Deactivate all knowledge units in this dimension
-        const knowledgeUnits = this.getKnowledgeByDimension(name);
-        for (const unit of knowledgeUnits) {
-            this.knowledgeRegistry.deactivateUnit(this.getUnitName(unit));
-        }
-    }
-    /**
-     * Get a comprehensive summary of the system
-     */
-    getSystemSummary() {
-        return {
-            dimensions: this.dimensionRegistry.getSummary(),
-            knowledge: this.knowledgeRegistry.getSummary()
-        };
-    }
-    /**
-     * Get knowledge units ordered by complexity
-     */
-    getKnowledgeByComplexity() {
-        return this.knowledgeRegistry.getOrderedByComplexity();
-    }
-    /**
-     * Get dimensions ordered by complexity
-     */
-    getDimensionsByComplexity() {
-        return this.dimensionRegistry.getOrderedByComplexity();
-    }
-    /**
-     * Helper method to get unit name
-     */
-    getUnitName(unit) {
-        if ('name' in unit && unit.name)
-            return unit.name;
-        if ('id' in unit && unit.id)
-            return unit.id;
-        return 'unknown';
-    }
-    /**
-     * Check if system is initialized
-     */
-    isSystemInitialized() {
-        return this.isInitialized;
-    }
-}
-exports.ZeroPointSystem = ZeroPointSystem;

package/dist/core/applyLaws.js

@@ -1,12 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.applyLaws = applyLaws;
-function applyLaws(subject, laws, context) {
-    let result = subject;
-    for (const law of laws) {
-        if (typeof law.apply === 'function') {
-            result = law.apply(result, context);
-        }
-    }
-    return result;
-}

package/dist/core/applyOperations.js

@@ -1,21 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.apply = apply;
-exports.applyAll = applyAll;
-const ComplianceSystem_1 = require("./ComplianceSystem");
-function apply(subject, op, context) {
-    // Validate operation for full compliance before execution
-    if (!(0, ComplianceSystem_1.validateFullCompliance)(op, context)) {
-        throw new Error(`Operation ${op.name} failed comprehensive compliance check`);
-    }
-    return op.execute(subject, context);
-}
-function applyAll(subject, ops, context) {
-    // Validate all operations for full compliance before execution
-    for (const op of ops) {
-        if (!(0, ComplianceSystem_1.validateFullCompliance)(op, context)) {
-            throw new Error(`Operation ${op.name} failed comprehensive compliance check`);
-        }
-    }
-    return ops.reduce((acc, op) => apply(acc, op, context), subject);
-}

package/dist/devices/DeviceRegistry.js

@@ -1,151 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DeviceRegistry = void 0;
-const MetaphysicalLawRegistry_1 = require("../laws/MetaphysicalLawRegistry");
-const ResonanceDevices_1 = require("./ResonanceDevices");
-/**
- * Registry for resonance devices
- * Manages devices and their interactions with metaphysical laws
- */
-class DeviceRegistry {
-    constructor() {
-        this.devices = new Map();
-        this.lawRegistry = MetaphysicalLawRegistry_1.MetaphysicalLawRegistry.getInstance();
-        this.initializeDefaultDevices();
-    }
-    static getInstance() {
-        if (!DeviceRegistry.instance) {
-            DeviceRegistry.instance = new DeviceRegistry();
-        }
-        return DeviceRegistry.instance;
-    }
-    /**
-     * Initialize default devices
-     */
-    initializeDefaultDevices() {
-        this.registerDevice(new ResonanceDevices_1.HarmonicAmplifier());
-        this.registerDevice(new ResonanceDevices_1.ConsciousnessResonator());
-        this.registerDevice(new ResonanceDevices_1.UnityHarmonizer());
-        this.registerDevice(new ResonanceDevices_1.PolarityBalancer());
-    }
-    /**
-     * Register a new device
-     */
-    registerDevice(device) {
-        // Apply all metaphysical laws to the device
-        const laws = this.lawRegistry.getAllLaws();
-        laws.forEach(law => {
-            law.apply(device);
-        });
-        this.devices.set(device.name, device);
-    }
-    /**
-     * Get a device by name
-     */
-    getDevice(name) {
-        return this.devices.get(name);
-    }
-    /**
-     * Get all devices
-     */
-    getAllDevices() {
-        return Array.from(this.devices.values());
-    }
-    /**
-     * Get devices by type
-     */
-    getDevicesByType(type) {
-        return Array.from(this.devices.values()).filter(device => device.type === type);
-    }
-    /**
-     * Tune all devices to a specific frequency
-     */
-    tuneAllDevices(frequency) {
-        this.devices.forEach(device => {
-            device.tuneTo(frequency);
-        });
-    }
-    /**
-     * Create a device network for coordinated amplification
-     */
-    createDeviceNetwork() {
-        const devices = Array.from(this.devices.values());
-        const network = {
-            devices: devices.map(device => ({
-                name: device.name,
-                type: device.type,
-                resonanceFrequency: device.resonanceFrequency,
-                amplificationFactor: device.amplificationFactor
-            })),
-            coordinatedAmplification: this.calculateCoordinatedAmplification(devices)
-        };
-        return network;
-    }
-    /**
-     * Calculate coordinated amplification from multiple devices
-     */
-    calculateCoordinatedAmplification(devices) {
-        if (devices.length === 0)
-            return 0;
-        const totalAmplification = devices.reduce((sum, device) => {
-            return sum + device.amplificationFactor;
-        }, 0);
-        const harmonicFactor = devices.length > 1 ? Math.log2(devices.length) : 1;
-        return totalAmplification * harmonicFactor;
-    }
-    /**
-     * Amplify a target using all devices
-     */
-    amplifyWithAllDevices(target) {
-        const devices = Array.from(this.devices.values());
-        const amplifications = devices.map(device => ({
-            device: device.name,
-            amplification: device.amplify(target),
-            resonance: device.calculateResonance(target.vibrationalFrequency || 1)
-        }));
-        const totalAmplification = amplifications.reduce((sum, amp) => sum + amp.amplification, 0);
-        return {
-            target,
-            amplifications,
-            totalAmplification,
-            averageResonance: amplifications.reduce((sum, amp) => sum + amp.resonance, 0) / amplifications.length
-        };
-    }
-    /**
-     * Create a resonance field using multiple devices
-     */
-    createMultiDeviceField(radius) {
-        const devices = Array.from(this.devices.values());
-        const fields = devices.map(device => device.createResonanceField(radius));
-        return {
-            combinedField: {
-                radius,
-                devices: devices.length,
-                totalAmplification: this.calculateCoordinatedAmplification(devices),
-                fieldStrength: fields.reduce((sum, field) => sum + field.fieldStrength, 0),
-                harmonics: fields.flatMap(field => field.harmonics)
-            },
-            individualFields: fields
-        };
-    }
-    /**
-     * Get device signatures for analysis
-     */
-    getDeviceSignatures() {
-        return Array.from(this.devices.values()).map(device => ({
-            name: device.name,
-            type: device.type,
-            signature: device.getResonanceSignature()
-        }));
-    }
-    /**
-     * Find devices that resonate with a target
-     */
-    getResonatingDevices(target, threshold = 0.5) {
-        return Array.from(this.devices.values()).filter(device => {
-            const resonance = device.calculateResonance(target.vibrationalFrequency || 1);
-            return resonance >= threshold;
-        });
-    }
-}
-exports.DeviceRegistry = DeviceRegistry;

package/dist/devices/ResonanceDevice.js

@@ -1,92 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ResonanceDevice = void 0;
-const MetaphysicalArtifact_1 = require("../artifacts/MetaphysicalArtifact");
-/**
- * Base class for resonance devices
- * Devices that amplify, harmonize, or transform metaphysical energies
- */
-class ResonanceDevice extends MetaphysicalArtifact_1.MetaphysicalArtifact {
-    constructor(name, description, type) {
-        super(name, description, type);
-        this.resonanceFrequency = 0;
-        this.amplificationFactor = 1;
-        this.harmonicMultipliers = [1, 2, 3, 5, 8]; // Golden ratio harmonics
-        this.targetFrequencies = [];
-    }
-    /**
-     * Tune the device to a specific frequency
-     */
-    tuneTo(frequency) {
-        this.resonanceFrequency = frequency;
-        this.targetFrequencies = this.harmonicMultipliers.map(mult => frequency * mult);
-        this.amplificationFactor = this.calculateAmplificationFactor();
-    }
-    /**
-     * Calculate amplification factor based on resonance alignment
-     */
-    calculateAmplificationFactor() {
-        const baseAmplification = 1.5;
-        const lawCompliance = Array.from(this.lawCompliance.values()).filter(Boolean).length;
-        return baseAmplification * (1 + lawCompliance * 0.2);
-    }
-    /**
-     * Amplify a target's vibrational frequency
-     */
-    amplify(target) {
-        const targetFrequency = target.vibrationalFrequency || 1;
-        const resonance = this.calculateResonance(targetFrequency);
-        return targetFrequency * this.amplificationFactor * resonance;
-    }
-    /**
-     * Calculate resonance between device and target frequency
-     */
-    calculateResonance(targetFrequency) {
-        const frequencyDiff = Math.abs(this.resonanceFrequency - targetFrequency);
-        const maxDiff = Math.max(this.resonanceFrequency, targetFrequency);
-        return Math.max(0, 1 - (frequencyDiff / maxDiff));
-    }
-    /**
-     * Harmonize multiple frequencies
-     */
-    harmonize(frequencies) {
-        if (frequencies.length === 0)
-            return 0;
-        const harmonicMean = frequencies.reduce((sum, freq) => sum + (1 / freq), 0);
-        const harmonizedFrequency = frequencies.length / harmonicMean;
-        return this.amplify({ vibrationalFrequency: harmonizedFrequency });
-    }
-    /**
-     * Create a resonance field around the device
-     */
-    createResonanceField(radius) {
-        return {
-            center: this,
-            radius,
-            frequency: this.resonanceFrequency,
-            amplification: this.amplificationFactor,
-            harmonics: this.targetFrequencies,
-            fieldStrength: this.calculateFieldStrength(radius)
-        };
-    }
-    /**
-     * Calculate field strength at a given radius
-     */
-    calculateFieldStrength(radius) {
-        const baseStrength = this.powerLevel * this.consciousnessResonance;
-        return baseStrength / (1 + radius * 0.1); // Inverse square law approximation
-    }
-    /**
-     * Get device resonance signature
-     */
-    getResonanceSignature() {
-        return {
-            ...this.getMetaphysicalSignature(),
-            resonanceFrequency: this.resonanceFrequency,
-            amplificationFactor: this.amplificationFactor,
-            harmonicMultipliers: this.harmonicMultipliers,
-            targetFrequencies: this.targetFrequencies
-        };
-    }
-}
-exports.ResonanceDevice = ResonanceDevice;