@holoscript/plugin-economic-primitives 2.0.1 → 2.0.2

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@holoscript/plugin-economic-primitives",
-  "version": "2.0.1",
+  "version": "2.0.2",
   "main": "src/index.ts",
   "peerDependencies": {
-    "@holoscript/core": "8.0.6"
+    "@holoscript/core": ">=8.0.0"
   },
   "license": "MIT",
   "scripts": {
     "test": "vitest run --passWithNoTests",
     "test:coverage": "vitest run --coverage --passWithNoTests"
   }
-}
+}

package/src/index.ts

@@ -1,7 +1,24 @@
-export { createMarketplaceListingHandler, type MarketplaceListingConfig, type ListingStatus, type PricingModel } from './traits/MarketplaceListingTrait';
-export { createRoyaltyStreamHandler, type RoyaltyStreamConfig, type RoyaltySplit } from './traits/RoyaltyStreamTrait';
-export { createAgentOwnedEntityHandler, type AgentOwnedEntityConfig } from './traits/AgentOwnedEntityTrait';
-export { createFoundationDAOHandler, type FoundationDAOConfig, type FoundationDAOState, type Proposal } from './traits/FoundationDAOTrait';
+export {
+  createMarketplaceListingHandler,
+  type MarketplaceListingConfig,
+  type ListingStatus,
+  type PricingModel,
+} from './traits/MarketplaceListingTrait';
+export {
+  createRoyaltyStreamHandler,
+  type RoyaltyStreamConfig,
+  type RoyaltySplit,
+} from './traits/RoyaltyStreamTrait';
+export {
+  createAgentOwnedEntityHandler,
+  type AgentOwnedEntityConfig,
+} from './traits/AgentOwnedEntityTrait';
+export {
+  createFoundationDAOHandler,
+  type FoundationDAOConfig,
+  type FoundationDAOState,
+  type Proposal,
+} from './traits/FoundationDAOTrait';
 export * from './traits/types';
 
 import { createMarketplaceListingHandler } from './traits/MarketplaceListingTrait';
@@ -9,5 +26,14 @@ import { createRoyaltyStreamHandler } from './traits/RoyaltyStreamTrait';
 import { createAgentOwnedEntityHandler } from './traits/AgentOwnedEntityTrait';
 import { createFoundationDAOHandler } from './traits/FoundationDAOTrait';
 
-export const pluginMeta = { name: '@holoscript/plugin-economic-primitives', version: '1.0.0', traits: ['marketplace_listing', 'royalty_stream', 'agent_owned_entity', 'foundation_dao'] };
-export const traitHandlers = [createMarketplaceListingHandler(), createRoyaltyStreamHandler(), createAgentOwnedEntityHandler(), createFoundationDAOHandler()];
+export const pluginMeta = {
+  name: '@holoscript/plugin-economic-primitives',
+  version: '1.0.0',
+  traits: ['marketplace_listing', 'royalty_stream', 'agent_owned_entity', 'foundation_dao'],
+};
+export const traitHandlers = [
+  createMarketplaceListingHandler(),
+  createRoyaltyStreamHandler(),
+  createAgentOwnedEntityHandler(),
+  createFoundationDAOHandler(),
+];

package/src/traits/AgentOwnedEntityTrait.ts

@@ -20,25 +20,74 @@ export interface AgentOwnedEntityState {
   isActive: boolean;
 }
 
-const defaultConfig: AgentOwnedEntityConfig = { entityId: '', ownerAgentId: '', entityType: 'trait', walletAddress: '', revenueShare: 100, autonomyLevel: 'limited', spendingLimitPerDay: 10, allowedActions: ['list', 'price', 'respond'] };
+const defaultConfig: AgentOwnedEntityConfig = {
+  entityId: '',
+  ownerAgentId: '',
+  entityType: 'trait',
+  walletAddress: '',
+  revenueShare: 100,
+  autonomyLevel: 'limited',
+  spendingLimitPerDay: 10,
+  allowedActions: ['list', 'price', 'respond'],
+};
 
 export function createAgentOwnedEntityHandler(): TraitHandler<AgentOwnedEntityConfig> {
-  return { name: 'agent_owned_entity', defaultConfig,
-    onAttach(n: HSPlusNode, c: AgentOwnedEntityConfig, ctx: TraitContext) { n.__aoeState = { balance: 0, totalEarned: 0, totalSpent: 0, transactionCount: 0, isActive: true }; ctx.emit?.('aoe:registered', { entity: c.entityId, owner: c.ownerAgentId, autonomy: c.autonomyLevel }); },
-    onDetach(n: HSPlusNode, _c: AgentOwnedEntityConfig, ctx: TraitContext) { delete n.__aoeState; ctx.emit?.('aoe:deregistered'); },
+  return {
+    name: 'agent_owned_entity',
+    defaultConfig,
+    onAttach(n: HSPlusNode, c: AgentOwnedEntityConfig, ctx: TraitContext) {
+      n.__aoeState = {
+        balance: 0,
+        totalEarned: 0,
+        totalSpent: 0,
+        transactionCount: 0,
+        isActive: true,
+      };
+      ctx.emit?.('aoe:registered', {
+        entity: c.entityId,
+        owner: c.ownerAgentId,
+        autonomy: c.autonomyLevel,
+      });
+    },
+    onDetach(n: HSPlusNode, _c: AgentOwnedEntityConfig, ctx: TraitContext) {
+      delete n.__aoeState;
+      ctx.emit?.('aoe:deregistered');
+    },
     onUpdate() {},
     onEvent(n: HSPlusNode, c: AgentOwnedEntityConfig, ctx: TraitContext, e: TraitEvent) {
-      const s = n.__aoeState as AgentOwnedEntityState | undefined; if (!s || !s.isActive) return;
-      if (e.type === 'aoe:earn') { const amt = (e.payload?.amount as number) ?? 0; s.balance += amt; s.totalEarned += amt; s.transactionCount++; ctx.emit?.('aoe:earned', { amount: amt, balance: s.balance }); }
+      const s = n.__aoeState as AgentOwnedEntityState | undefined;
+      if (!s || !s.isActive) return;
+      if (e.type === 'aoe:earn') {
+        const amt = (e.payload?.amount as number) ?? 0;
+        s.balance += amt;
+        s.totalEarned += amt;
+        s.transactionCount++;
+        ctx.emit?.('aoe:earned', { amount: amt, balance: s.balance });
+      }
       if (e.type === 'aoe:spend') {
         const amt = (e.payload?.amount as number) ?? 0;
         const action = (e.payload?.action as string) ?? '';
-        if (amt > c.spendingLimitPerDay) { ctx.emit?.('aoe:spend_rejected', { amount: amt, limit: c.spendingLimitPerDay }); return; }
-        if (!c.allowedActions.includes(action) && c.autonomyLevel !== 'full') { ctx.emit?.('aoe:action_denied', { action }); return; }
-        if (s.balance >= amt) { s.balance -= amt; s.totalSpent += amt; s.transactionCount++; ctx.emit?.('aoe:spent', { amount: amt, action, balance: s.balance }); }
-        else { ctx.emit?.('aoe:insufficient_balance', { requested: amt, available: s.balance }); }
+        if (amt > c.spendingLimitPerDay) {
+          ctx.emit?.('aoe:spend_rejected', { amount: amt, limit: c.spendingLimitPerDay });
+          return;
+        }
+        if (!c.allowedActions.includes(action) && c.autonomyLevel !== 'full') {
+          ctx.emit?.('aoe:action_denied', { action });
+          return;
+        }
+        if (s.balance >= amt) {
+          s.balance -= amt;
+          s.totalSpent += amt;
+          s.transactionCount++;
+          ctx.emit?.('aoe:spent', { amount: amt, action, balance: s.balance });
+        } else {
+          ctx.emit?.('aoe:insufficient_balance', { requested: amt, available: s.balance });
+        }
+      }
+      if (e.type === 'aoe:deactivate') {
+        s.isActive = false;
+        ctx.emit?.('aoe:deactivated');
       }
-      if (e.type === 'aoe:deactivate') { s.isActive = false; ctx.emit?.('aoe:deactivated'); }
     },
   };
 }

package/src/traits/FoundationDAOTrait.ts

@@ -39,7 +39,7 @@ const defaultConfig: FoundationDAOConfig = {
   governanceToken: 'HOLO_GOV',
   quorumPercent: 33,
   executionDelayHours: 48,
-  multisigOwnersCount: 9
+  multisigOwnersCount: 9,
 };
 
 export function createFoundationDAOHandler(): TraitHandler<FoundationDAOConfig> {
@@ -148,70 +148,73 @@ export function createFoundationDAOHandler(): TraitHandler<FoundationDAOConfig>
       const s = n.__daoState as FoundationDAOState;
       if (!s) return;
       if (e.type === 'dao:propose') {
-         const nowMs = Date.now();
-         const proposal: Proposal = {
-           id: `prop_${nowMs}`,
-           title: (e.payload?.title as string) || 'General Update',
-           votesFor: 0,
-           votesAgainst: 0,
-           status: 'active',
-           zoneId: typeof e.payload?.zoneId === 'string' ? (e.payload.zoneId as string) : undefined,
-           requestedAmountX402:
-             typeof e.payload?.requestedAmountX402 === 'number'
-               ? (e.payload.requestedAmountX402 as number)
-               : undefined,
-           createdAtMs: nowMs,
-           voterWeights: {},
-         };
-         s.activeProposals.push(proposal);
-         ctx.emit?.('dao:proposal_created', { proposal });
+        const nowMs = Date.now();
+        const proposal: Proposal = {
+          id: `prop_${nowMs}`,
+          title: (e.payload?.title as string) || 'General Update',
+          votesFor: 0,
+          votesAgainst: 0,
+          status: 'active',
+          zoneId: typeof e.payload?.zoneId === 'string' ? (e.payload.zoneId as string) : undefined,
+          requestedAmountX402:
+            typeof e.payload?.requestedAmountX402 === 'number'
+              ? (e.payload.requestedAmountX402 as number)
+              : undefined,
+          createdAtMs: nowMs,
+          voterWeights: {},
+        };
+        s.activeProposals.push(proposal);
+        ctx.emit?.('dao:proposal_created', { proposal });
       } else if (e.type === 'dao:vote') {
-         const pid = e.payload?.proposalId as string;
-         const prop = s.activeProposals.find(p => p.id === pid);
-         if (prop && prop.status !== 'executed') {
-           const voterId = typeof e.payload?.voterId === 'string' ? (e.payload.voterId as string) : 'anonymous_voter';
-           const support = Boolean(e.payload?.support);
-           const weight = typeof e.payload?.weight === 'number' ? (e.payload.weight as number) : 1;
-           prop.status = 'active';
-           delete prop.executableAtMs;
-           applyVote(prop, voterId, support, weight);
-           maybeConcludeProposal(prop, c, s, ctx, Date.now());
-           executeProposal(prop, s, ctx, Date.now());
-         }
+        const pid = e.payload?.proposalId as string;
+        const prop = s.activeProposals.find((p) => p.id === pid);
+        if (prop && prop.status !== 'executed') {
+          const voterId =
+            typeof e.payload?.voterId === 'string'
+              ? (e.payload.voterId as string)
+              : 'anonymous_voter';
+          const support = Boolean(e.payload?.support);
+          const weight = typeof e.payload?.weight === 'number' ? (e.payload.weight as number) : 1;
+          prop.status = 'active';
+          delete prop.executableAtMs;
+          applyVote(prop, voterId, support, weight);
+          maybeConcludeProposal(prop, c, s, ctx, Date.now());
+          executeProposal(prop, s, ctx, Date.now());
+        }
       } else if (e.type === 'dao:autonomous_vote') {
-         const pid = e.payload?.proposalId as string;
-         const prop = s.activeProposals.find(p => p.id === pid);
-         if (!prop || prop.status !== 'active') return;
-
-         const agents = Array.isArray(e.payload?.agents)
-           ? (e.payload?.agents as Array<Record<string, unknown>>)
-           : [];
-
-         for (const agent of agents) {
-           const voterId = typeof agent.agentId === 'string' ? (agent.agentId as string) : 'agent';
-           const support =
-             typeof agent.support === 'boolean'
-               ? (agent.support as boolean)
-               : prop.requestedAmountX402
-                 ? prop.requestedAmountX402 <= s.treasuryBalanceX402
-                 : true;
-           const weight = typeof agent.weight === 'number' ? (agent.weight as number) : 1;
-           applyVote(prop, voterId, support, weight);
-         }
-
-         maybeConcludeProposal(prop, c, s, ctx, Date.now());
+        const pid = e.payload?.proposalId as string;
+        const prop = s.activeProposals.find((p) => p.id === pid);
+        if (!prop || prop.status !== 'active') return;
+
+        const agents = Array.isArray(e.payload?.agents)
+          ? (e.payload?.agents as Array<Record<string, unknown>>)
+          : [];
+
+        for (const agent of agents) {
+          const voterId = typeof agent.agentId === 'string' ? (agent.agentId as string) : 'agent';
+          const support =
+            typeof agent.support === 'boolean'
+              ? (agent.support as boolean)
+              : prop.requestedAmountX402
+                ? prop.requestedAmountX402 <= s.treasuryBalanceX402
+                : true;
+          const weight = typeof agent.weight === 'number' ? (agent.weight as number) : 1;
+          applyVote(prop, voterId, support, weight);
+        }
+
+        maybeConcludeProposal(prop, c, s, ctx, Date.now());
         executeProposal(prop, s, ctx, Date.now());
       } else if (e.type === 'dao:execute') {
-         const nowMs =
-           typeof e.payload?.nowMs === 'number' ? (e.payload.nowMs as number) : Date.now();
-
-         if (typeof e.payload?.proposalId === 'string') {
-           const prop = s.activeProposals.find(p => p.id === e.payload!.proposalId);
-           if (prop) executeProposal(prop, s, ctx, nowMs);
-         } else {
-           s.activeProposals.forEach((p) => executeProposal(p, s, ctx, nowMs));
-         }
+        const nowMs =
+          typeof e.payload?.nowMs === 'number' ? (e.payload.nowMs as number) : Date.now();
+
+        if (typeof e.payload?.proposalId === 'string') {
+          const prop = s.activeProposals.find((p) => p.id === e.payload!.proposalId);
+          if (prop) executeProposal(prop, s, ctx, nowMs);
+        } else {
+          s.activeProposals.forEach((p) => executeProposal(p, s, ctx, nowMs));
+        }
       }
-    }
+    },
   };
 }

package/src/traits/MarketplaceListingTrait.ts

@@ -27,19 +27,65 @@ export interface MarketplaceListingState {
   reviewCount: number;
 }
 
-const defaultConfig: MarketplaceListingConfig = { listingId: '', title: '', description: '', sellerAgentId: '', assetType: 'trait', price: 0, currency: 'USDC', pricingModel: 'fixed', royaltyPercent: 10, tags: [], licenseType: 'MIT' };
+const defaultConfig: MarketplaceListingConfig = {
+  listingId: '',
+  title: '',
+  description: '',
+  sellerAgentId: '',
+  assetType: 'trait',
+  price: 0,
+  currency: 'USDC',
+  pricingModel: 'fixed',
+  royaltyPercent: 10,
+  tags: [],
+  licenseType: 'MIT',
+};
 
 export function createMarketplaceListingHandler(): TraitHandler<MarketplaceListingConfig> {
-  return { name: 'marketplace_listing', defaultConfig,
-    onAttach(n: HSPlusNode, c: MarketplaceListingConfig, ctx: TraitContext) { n.__listingState = { status: 'draft' as ListingStatus, views: 0, purchases: 0, revenue: 0, rating: 0, reviewCount: 0 }; ctx.emit?.('listing:created', { title: c.title, price: c.price }); },
-    onDetach(n: HSPlusNode, _c: MarketplaceListingConfig, ctx: TraitContext) { delete n.__listingState; ctx.emit?.('listing:removed'); },
+  return {
+    name: 'marketplace_listing',
+    defaultConfig,
+    onAttach(n: HSPlusNode, c: MarketplaceListingConfig, ctx: TraitContext) {
+      n.__listingState = {
+        status: 'draft' as ListingStatus,
+        views: 0,
+        purchases: 0,
+        revenue: 0,
+        rating: 0,
+        reviewCount: 0,
+      };
+      ctx.emit?.('listing:created', { title: c.title, price: c.price });
+    },
+    onDetach(n: HSPlusNode, _c: MarketplaceListingConfig, ctx: TraitContext) {
+      delete n.__listingState;
+      ctx.emit?.('listing:removed');
+    },
     onUpdate() {},
     onEvent(n: HSPlusNode, c: MarketplaceListingConfig, ctx: TraitContext, e: TraitEvent) {
-      const s = n.__listingState as MarketplaceListingState | undefined; if (!s) return;
-      if (e.type === 'listing:publish') { s.status = 'active'; ctx.emit?.('listing:published', { listingId: c.listingId }); }
-      if (e.type === 'listing:purchase') { s.purchases++; s.revenue += c.price; ctx.emit?.('listing:sold', { buyer: e.payload?.buyerAgentId, revenue: s.revenue, royalty: c.price * c.royaltyPercent / 100 }); }
-      if (e.type === 'listing:view') { s.views++; }
-      if (e.type === 'listing:review') { const rating = (e.payload?.rating as number) ?? 5; s.rating = (s.rating * s.reviewCount + rating) / (s.reviewCount + 1); s.reviewCount++; ctx.emit?.('listing:reviewed', { avgRating: s.rating }); }
+      const s = n.__listingState as MarketplaceListingState | undefined;
+      if (!s) return;
+      if (e.type === 'listing:publish') {
+        s.status = 'active';
+        ctx.emit?.('listing:published', { listingId: c.listingId });
+      }
+      if (e.type === 'listing:purchase') {
+        s.purchases++;
+        s.revenue += c.price;
+        ctx.emit?.('listing:sold', {
+          buyer: e.payload?.buyerAgentId,
+          revenue: s.revenue,
+          royalty: (c.price * c.royaltyPercent) / 100,
+        });
+      }
+      if (e.type === 'listing:view') {
+        s.views++;
+      }
+      if (e.type === 'listing:review') {
+        const rating = (e.payload?.rating as number) ?? 5;
+        s.rating = (s.rating * s.reviewCount + rating) / (s.reviewCount + 1);
+        s.reviewCount++;
+        ctx.emit?.('listing:reviewed', { avgRating: s.rating });
+      }
     },
   };
 }

package/src/traits/RoyaltyStreamTrait.ts

@@ -1,31 +1,76 @@
 /** @royalty_stream Trait — Revenue sharing and royalty distribution. @trait royalty_stream */
 import type { TraitHandler, HSPlusNode, TraitContext, TraitEvent } from './types';
 
-export interface RoyaltySplit { recipientId: string; percent: number; walletAddress?: string; }
-export interface RoyaltyStreamConfig { assetId: string; splits: RoyaltySplit[]; currency: string; minimumPayout: number; payoutFrequency: 'instant' | 'daily' | 'weekly' | 'monthly'; }
-export interface RoyaltyStreamState { totalCollected: number; totalDistributed: number; pendingPayout: number; distributionCount: number; }
+export interface RoyaltySplit {
+  recipientId: string;
+  percent: number;
+  walletAddress?: string;
+}
+export interface RoyaltyStreamConfig {
+  assetId: string;
+  splits: RoyaltySplit[];
+  currency: string;
+  minimumPayout: number;
+  payoutFrequency: 'instant' | 'daily' | 'weekly' | 'monthly';
+}
+export interface RoyaltyStreamState {
+  totalCollected: number;
+  totalDistributed: number;
+  pendingPayout: number;
+  distributionCount: number;
+}
 
-const defaultConfig: RoyaltyStreamConfig = { assetId: '', splits: [], currency: 'USDC', minimumPayout: 1, payoutFrequency: 'instant' };
+const defaultConfig: RoyaltyStreamConfig = {
+  assetId: '',
+  splits: [],
+  currency: 'USDC',
+  minimumPayout: 1,
+  payoutFrequency: 'instant',
+};
 
 export function createRoyaltyStreamHandler(): TraitHandler<RoyaltyStreamConfig> {
-  return { name: 'royalty_stream', defaultConfig,
-    onAttach(n: HSPlusNode, _c: RoyaltyStreamConfig, ctx: TraitContext) { n.__royaltyState = { totalCollected: 0, totalDistributed: 0, pendingPayout: 0, distributionCount: 0 }; ctx.emit?.('royalty:stream_created'); },
-    onDetach(n: HSPlusNode, _c: RoyaltyStreamConfig, ctx: TraitContext) { delete n.__royaltyState; ctx.emit?.('royalty:stream_closed'); },
+  return {
+    name: 'royalty_stream',
+    defaultConfig,
+    onAttach(n: HSPlusNode, _c: RoyaltyStreamConfig, ctx: TraitContext) {
+      n.__royaltyState = {
+        totalCollected: 0,
+        totalDistributed: 0,
+        pendingPayout: 0,
+        distributionCount: 0,
+      };
+      ctx.emit?.('royalty:stream_created');
+    },
+    onDetach(n: HSPlusNode, _c: RoyaltyStreamConfig, ctx: TraitContext) {
+      delete n.__royaltyState;
+      ctx.emit?.('royalty:stream_closed');
+    },
     onUpdate() {},
     onEvent(n: HSPlusNode, c: RoyaltyStreamConfig, ctx: TraitContext, e: TraitEvent) {
-      const s = n.__royaltyState as RoyaltyStreamState | undefined; if (!s) return;
+      const s = n.__royaltyState as RoyaltyStreamState | undefined;
+      if (!s) return;
       if (e.type === 'royalty:collect') {
         const amount = (e.payload?.amount as number) ?? 0;
-        s.totalCollected += amount; s.pendingPayout += amount;
+        s.totalCollected += amount;
+        s.pendingPayout += amount;
         if (c.payoutFrequency === 'instant' && s.pendingPayout >= c.minimumPayout) {
-          const distributions = c.splits.map(split => ({ recipient: split.recipientId, amount: s.pendingPayout * split.percent / 100 }));
-          s.totalDistributed += s.pendingPayout; s.pendingPayout = 0; s.distributionCount++;
+          const distributions = c.splits.map((split) => ({
+            recipient: split.recipientId,
+            amount: (s.pendingPayout * split.percent) / 100,
+          }));
+          s.totalDistributed += s.pendingPayout;
+          s.pendingPayout = 0;
+          s.distributionCount++;
           ctx.emit?.('royalty:distributed', { distributions, total: s.totalDistributed });
-        } else { ctx.emit?.('royalty:collected', { pending: s.pendingPayout }); }
+        } else {
+          ctx.emit?.('royalty:collected', { pending: s.pendingPayout });
+        }
       }
       if (e.type === 'royalty:flush') {
         if (s.pendingPayout > 0) {
-          s.totalDistributed += s.pendingPayout; s.pendingPayout = 0; s.distributionCount++;
+          s.totalDistributed += s.pendingPayout;
+          s.pendingPayout = 0;
+          s.distributionCount++;
           ctx.emit?.('royalty:flushed', { totalDistributed: s.totalDistributed });
         }
       }

package/src/traits/__tests__/FoundationDAOTrait.test.ts

@@ -32,23 +32,38 @@ describe('FoundationDAOTrait', () => {
 
     handler.onAttach(node, config, { emit: (type) => emitted.push(type) });
 
-    handler.onEvent(node, config, { emit: (type) => emitted.push(type) }, {
-      type: 'dao:propose',
-      payload: { title: 'Fund autonomous zone indexing' },
-    });
+    handler.onEvent(
+      node,
+      config,
+      { emit: (type) => emitted.push(type) },
+      {
+        type: 'dao:propose',
+        payload: { title: 'Fund autonomous zone indexing' },
+      }
+    );
 
     const state = node.__daoState as any;
     const proposal = state.activeProposals[0];
 
-    handler.onEvent(node, config, { emit: (type) => emitted.push(type) }, {
-      type: 'dao:vote',
-      payload: { proposalId: proposal.id, voterId: 'agent_a', support: true, weight: 2 },
-    });
-
-    handler.onEvent(node, config, { emit: (type) => emitted.push(type) }, {
-      type: 'dao:vote',
-      payload: { proposalId: proposal.id, voterId: 'agent_a', support: false, weight: 1 },
-    });
+    handler.onEvent(
+      node,
+      config,
+      { emit: (type) => emitted.push(type) },
+      {
+        type: 'dao:vote',
+        payload: { proposalId: proposal.id, voterId: 'agent_a', support: true, weight: 2 },
+      }
+    );
+
+    handler.onEvent(
+      node,
+      config,
+      { emit: (type) => emitted.push(type) },
+      {
+        type: 'dao:vote',
+        payload: { proposalId: proposal.id, voterId: 'agent_a', support: false, weight: 1 },
+      }
+    );
 
     expect(proposal.votesFor).toBe(0);
     expect(proposal.votesAgainst).toBe(1);
@@ -71,28 +86,38 @@ describe('FoundationDAOTrait', () => {
       emit: (type, payload) => emitted.push({ type, payload }),
     });
 
-    handler.onEvent(node, config, { emit: (type, payload) => emitted.push({ type, payload }) }, {
-      type: 'dao:propose',
-      payload: {
-        title: 'Fund sovereign spatial zone Z1',
-        zoneId: 'zone-z1',
-        requestedAmountX402: 250000,
-      },
-    });
+    handler.onEvent(
+      node,
+      config,
+      { emit: (type, payload) => emitted.push({ type, payload }) },
+      {
+        type: 'dao:propose',
+        payload: {
+          title: 'Fund sovereign spatial zone Z1',
+          zoneId: 'zone-z1',
+          requestedAmountX402: 250000,
+        },
+      }
+    );
 
     const state = node.__daoState as any;
     const proposal = state.activeProposals[0];
 
-    handler.onEvent(node, config, { emit: (type, payload) => emitted.push({ type, payload }) }, {
-      type: 'dao:autonomous_vote',
-      payload: {
-        proposalId: proposal.id,
-        agents: [
-          { agentId: 'agent_a', support: true, weight: 2 },
-          { agentId: 'agent_b', support: true, weight: 2 },
-        ],
-      },
-    });
+    handler.onEvent(
+      node,
+      config,
+      { emit: (type, payload) => emitted.push({ type, payload }) },
+      {
+        type: 'dao:autonomous_vote',
+        payload: {
+          proposalId: proposal.id,
+          agents: [
+            { agentId: 'agent_a', support: true, weight: 2 },
+            { agentId: 'agent_b', support: true, weight: 2 },
+          ],
+        },
+      }
+    );
 
     expect(proposal.status).toBe('executed');
     expect(state.allocations).toHaveLength(1);
@@ -123,24 +148,34 @@ describe('FoundationDAOTrait', () => {
     const state = node.__daoState as any;
     state.treasuryBalanceX402 = 100;
 
-    handler.onEvent(node, config, { emit: (type, payload) => emitted.push({ type, payload }) }, {
-      type: 'dao:propose',
-      payload: {
-        title: 'Huge funding ask',
-        zoneId: 'zone-z2',
-        requestedAmountX402: 5000,
-      },
-    });
+    handler.onEvent(
+      node,
+      config,
+      { emit: (type, payload) => emitted.push({ type, payload }) },
+      {
+        type: 'dao:propose',
+        payload: {
+          title: 'Huge funding ask',
+          zoneId: 'zone-z2',
+          requestedAmountX402: 5000,
+        },
+      }
+    );
 
     const proposal = state.activeProposals[0];
 
-    handler.onEvent(node, config, { emit: (type, payload) => emitted.push({ type, payload }) }, {
-      type: 'dao:autonomous_vote',
-      payload: {
-        proposalId: proposal.id,
-        agents: [{ agentId: 'agent_a', support: true, weight: 5 }],
-      },
-    });
+    handler.onEvent(
+      node,
+      config,
+      { emit: (type, payload) => emitted.push({ type, payload }) },
+      {
+        type: 'dao:autonomous_vote',
+        payload: {
+          proposalId: proposal.id,
+          agents: [{ agentId: 'agent_a', support: true, weight: 5 }],
+        },
+      }
+    );
 
     expect(proposal.status).toBe('passed');
     expect(state.allocations).toHaveLength(0);

package/src/traits/types.ts

@@ -1,4 +1,22 @@
-export interface HSPlusNode { id?: string; properties?: Record<string, unknown>; [key: string]: unknown; }
-export interface TraitContext { emit?: (event: string, payload?: unknown) => void; [key: string]: unknown; }
-export interface TraitEvent { type: string; payload?: Record<string, unknown>; [key: string]: unknown; }
-export interface TraitHandler<T = unknown> { name: string; defaultConfig: T; onAttach(n: HSPlusNode, c: T, ctx: TraitContext): void; onDetach(n: HSPlusNode, c: T, ctx: TraitContext): void; onUpdate(n: HSPlusNode, c: T, ctx: TraitContext, d: number): void; onEvent(n: HSPlusNode, c: T, ctx: TraitContext, e: TraitEvent): void; }
+export interface HSPlusNode {
+  id?: string;
+  properties?: Record<string, unknown>;
+  [key: string]: unknown;
+}
+export interface TraitContext {
+  emit?: (event: string, payload?: unknown) => void;
+  [key: string]: unknown;
+}
+export interface TraitEvent {
+  type: string;
+  payload?: Record<string, unknown>;
+  [key: string]: unknown;
+}
+export interface TraitHandler<T = unknown> {
+  name: string;
+  defaultConfig: T;
+  onAttach(n: HSPlusNode, c: T, ctx: TraitContext): void;
+  onDetach(n: HSPlusNode, c: T, ctx: TraitContext): void;
+  onUpdate(n: HSPlusNode, c: T, ctx: TraitContext, d: number): void;
+  onEvent(n: HSPlusNode, c: T, ctx: TraitContext, e: TraitEvent): void;
+}

package/tsconfig.json

@@ -1 +1,5 @@
-{ "extends": "../../../tsconfig.json", "compilerOptions": { "outDir": "dist", "rootDir": "src", "declaration": true }, "include": ["src"] }
+{
+  "extends": "../../../tsconfig.json",
+  "compilerOptions": { "outDir": "dist", "rootDir": "src", "declaration": true },
+  "include": ["src"]
+}

package/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2025-2026 HoloScript Contributors
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.