@ottochain/sdk 2.3.0 → 2.5.0

package/dist/esm/apps/corporate/state-machines/corp-shareholders.js

@@ -1,699 +1,721 @@
-import { defineFiberApp } from "../../../schema/fiber-app.js";
+import { defineFiberApp } from '../../../schema/fiber-app.js';
+import { signerIsParty, depInState } from '../../../schema/guards.js';
+import { addDependency } from '../../../schema/effects.js';
 /**
  * Shareholder meeting state machine managing annual/special meetings, record dates, proxy periods, voting, and certification of results.
  * Supports multiple share classes and cumulative voting.
  */
 export const corpShareholdersDef = defineFiberApp({
     metadata: {
-        name: "CorpShareholders",
-        app: "corporate",
-        type: "shareholders",
-        version: "1.0.0",
-        description: "Shareholder meeting state machine managing annual/special meetings, record dates, proxy periods, voting, and certification of results. Supports multiple share classes and cumulative voting.",
+        name: 'CorpShareholders',
+        app: 'corporate',
+        type: 'shareholders',
+        version: '1.0.0',
+        description: 'Shareholder meeting state machine managing annual/special meetings, record dates, proxy periods, voting, and certification of results. Supports multiple share classes and cumulative voting.',
         crossReferences: {
             entity: {
-                machine: "corporate-entity",
-                description: "Parent corporate entity",
-                foreignKey: "entityId",
+                machine: 'corporate-entity',
+                description: 'Parent corporate entity',
+                foreignKey: 'entityId',
             },
             proxies: {
-                machine: "corporate-proxy",
-                description: "Proxy grants for this meeting",
-                foreignKey: "meetingId",
+                machine: 'corporate-proxy',
+                description: 'Proxy grants for this meeting',
+                foreignKey: 'meetingId',
             },
             resolutions: {
-                machine: "corporate-resolution",
-                description: "Resolutions resulting from meeting votes",
-                foreignKey: "meetingId",
+                machine: 'corporate-resolution',
+                description: 'Resolutions resulting from meeting votes',
+                foreignKey: 'meetingId',
             },
             securities: {
-                machine: "corporate-securities",
-                description: "Share records for determining voting rights",
-                foreignKey: "entityId",
+                machine: 'corporate-securities',
+                description: 'Share records for determining voting rights',
+                foreignKey: 'entityId',
             },
         },
     },
     createSchema: {
-        required: ["meetingId", "entityId"],
+        required: ['meetingId', 'entityId', 'registrar'],
         properties: {
             meetingId: {
-                type: "string",
-                description: "Unique identifier for this shareholder meeting",
+                type: 'string',
+                description: 'Unique identifier for this shareholder meeting',
                 immutable: true,
             },
             entityId: {
-                type: "string",
-                description: "Reference to parent corporate-entity",
+                type: 'string',
+                description: 'Reference to parent corporate-entity',
+                immutable: true,
+            },
+            registrar: {
+                type: 'address',
+                description: 'State-pinned DAG address of the transfer agent / registrar authorized to register the eligible-shareholder roster of record. Verified against proofs[].address.',
                 immutable: true,
             },
             meetingType: {
-                type: "string",
-                enum: ["ANNUAL", "SPECIAL"],
-                description: "Annual meetings are required; special meetings called for specific purposes",
+                type: 'string',
+                enum: ['ANNUAL', 'SPECIAL'],
+                description: 'Annual meetings are required; special meetings called for specific purposes',
             },
             fiscalYear: {
-                type: "integer",
-                description: "Fiscal year for annual meetings",
+                type: 'integer',
+                description: 'Fiscal year for annual meetings',
             },
             scheduledDate: {
-                type: "string",
-                format: "date-time",
+                type: 'string',
+                format: 'date-time',
             },
             location: {
-                type: "object",
+                type: 'object',
                 properties: {
-                    physical: { type: "string", nullable: true },
-                    virtualUrl: { type: "string", nullable: true },
-                    isHybrid: { type: "boolean", default: false },
+                    physical: { type: 'string', nullable: true },
+                    virtualUrl: { type: 'string', nullable: true },
+                    isHybrid: { type: 'boolean', default: false },
                 },
             },
         },
     },
     stateSchema: {
         properties: {
-            meetingId: { type: "string", immutable: true },
-            entityId: { type: "string", immutable: true },
-            meetingType: { type: "string" },
-            fiscalYear: { type: "integer" },
-            scheduledDate: { type: "string", format: "date-time" },
-            location: { type: "object" },
-            calledBy: { $ref: "#/definitions/CalledBy", computed: true },
-            noticeInfo: { $ref: "#/definitions/NoticeInfo", computed: true },
+            meetingId: { type: 'string', immutable: true },
+            entityId: { type: 'string', immutable: true },
+            registrar: { type: 'address', immutable: true },
+            meetingType: { type: 'string' },
+            fiscalYear: { type: 'integer' },
+            scheduledDate: { type: 'string', format: 'date-time' },
+            location: { type: 'object' },
+            calledBy: { $ref: '#/definitions/CalledBy', computed: true },
+            noticeInfo: { $ref: '#/definitions/NoticeInfo', computed: true },
             recordDate: {
-                $ref: "#/definitions/RecordDate",
+                $ref: '#/definitions/RecordDate',
                 nullable: true,
                 computed: true,
             },
             eligibleVoters: {
-                type: "array",
-                items: { $ref: "#/definitions/EligibleVoter" },
+                type: 'array',
+                items: { $ref: '#/definitions/EligibleVoter' },
                 computed: true,
             },
             quorumRequirements: {
-                $ref: "#/definitions/QuorumRequirements",
+                $ref: '#/definitions/QuorumRequirements',
                 computed: true,
             },
             agenda: {
-                type: "array",
-                items: { $ref: "#/definitions/AgendaItem" },
+                type: 'array',
+                items: { $ref: '#/definitions/AgendaItem' },
                 computed: true,
             },
             proxyPeriod: {
-                $ref: "#/definitions/ProxyPeriod",
+                $ref: '#/definitions/ProxyPeriod',
                 nullable: true,
                 computed: true,
             },
             votes: {
-                type: "array",
-                items: { $ref: "#/definitions/Vote" },
+                type: 'array',
+                items: { $ref: '#/definitions/Vote' },
                 computed: true,
             },
             voteTallies: {
-                type: "array",
-                items: { $ref: "#/definitions/VoteTally" },
+                type: 'array',
+                items: { $ref: '#/definitions/VoteTally' },
                 computed: true,
             },
             inspectorOfElections: {
-                $ref: "#/definitions/Inspector",
+                $ref: '#/definitions/Inspector',
                 nullable: true,
                 computed: true,
             },
             sessionInfo: {
-                $ref: "#/definitions/SessionInfo",
+                $ref: '#/definitions/SessionInfo',
                 nullable: true,
                 computed: true,
             },
             certification: {
-                $ref: "#/definitions/Certification",
+                $ref: '#/definitions/Certification',
                 nullable: true,
                 computed: true,
             },
             status: {
-                type: "string",
-                enum: [
-                    "SCHEDULED",
-                    "RECORD_DATE_SET",
-                    "PROXY_PERIOD",
-                    "IN_SESSION",
-                    "VOTING",
-                    "CLOSED",
-                ],
+                type: 'string',
+                enum: ['SCHEDULED', 'RECORD_DATE_SET', 'PROXY_PERIOD', 'IN_SESSION', 'VOTING', 'CLOSED'],
                 computed: true,
             },
-            createdAt: { type: "timestamp", computed: true },
-            updatedAt: { type: "timestamp", computed: true },
+            createdAt: { type: 'timestamp', computed: true },
+            updatedAt: { type: 'timestamp', computed: true },
+            // Two-phase scheduling (#24): propose_schedule_annual binds the board-resolution fiber + records the
+            // pending meeting here; schedule_annual asserts the bound resolution is EXECUTED, then clears this.
+            pendingschedule_annual: { type: 'object', nullable: true, computed: true },
         },
     },
     eventSchemas: {
+        propose_schedule_annual: {
+            description: 'Phase 1 of annual-meeting scheduling: bind the executing board-resolution fiber (#24 _addDependency) and record the pending meeting',
+            required: ['meetingId', 'entityId', 'fiscalYear', 'scheduledDate', 'boardResolutionRef'],
+            properties: {
+                meetingId: { type: 'string' },
+                entityId: { type: 'string' },
+                fiscalYear: { type: 'integer' },
+                scheduledDate: { type: 'string', format: 'date-time' },
+                location: { type: 'object' },
+                boardResolutionRef: { type: 'string' },
+            },
+        },
         schedule_annual: {
-            description: "Schedule an annual shareholder meeting",
-            required: [
-                "meetingId",
-                "entityId",
-                "fiscalYear",
-                "scheduledDate",
-                "boardResolutionRef",
-            ],
+            description: 'Phase 2 of annual-meeting scheduling: execute once the bound board resolution is EXECUTED',
+            required: ['meetingId', 'entityId', 'fiscalYear', 'scheduledDate'],
             properties: {
-                meetingId: { type: "string" },
-                entityId: { type: "string" },
-                fiscalYear: { type: "integer" },
-                scheduledDate: { type: "string", format: "date-time" },
-                location: { type: "object" },
-                boardResolutionRef: { type: "string" },
+                meetingId: { type: 'string' },
+                entityId: { type: 'string' },
+                fiscalYear: { type: 'integer' },
+                scheduledDate: { type: 'string', format: 'date-time' },
+                location: { type: 'object' },
             },
         },
         schedule_special: {
-            description: "Schedule a special shareholder meeting",
-            required: [
-                "meetingId",
-                "entityId",
-                "scheduledDate",
-                "purpose",
-                "calledByType",
-            ],
+            description: 'Schedule a special shareholder meeting',
+            required: ['meetingId', 'entityId', 'scheduledDate', 'purpose', 'calledByType'],
             properties: {
-                meetingId: { type: "string" },
-                entityId: { type: "string" },
-                scheduledDate: { type: "string", format: "date-time" },
-                location: { type: "object" },
+                meetingId: { type: 'string' },
+                entityId: { type: 'string' },
+                scheduledDate: { type: 'string', format: 'date-time' },
+                location: { type: 'object' },
                 purpose: {
-                    type: "string",
-                    description: "Specific purpose for special meeting",
+                    type: 'string',
+                    description: 'Specific purpose for special meeting',
                 },
                 calledByType: {
-                    type: "string",
-                    enum: ["BOARD", "SHAREHOLDERS", "COURT"],
+                    type: 'string',
+                    enum: ['BOARD', 'SHAREHOLDERS', 'COURT'],
                 },
-                resolutionRef: { type: "string" },
-                petitionRef: { type: "string" },
+                resolutionRef: { type: 'string' },
+                petitionRef: { type: 'string' },
             },
         },
         set_record_date: {
-            description: "Board sets the record date for determining eligible shareholders",
-            required: ["recordDate", "resolutionRef"],
+            description: 'Board sets the record date for determining eligible shareholders',
+            required: ['recordDate', 'resolutionRef'],
             properties: {
-                recordDate: { type: "string", format: "date" },
-                resolutionRef: { type: "string" },
+                recordDate: { type: 'string', format: 'date' },
+                resolutionRef: { type: 'string' },
             },
         },
         register_eligible_shareholders: {
-            description: "Register shareholders of record as of record date",
-            required: ["shareholders", "totalSharesOutstanding"],
+            description: 'Register shareholders of record as of record date',
+            required: ['shareholders', 'totalSharesOutstanding'],
             properties: {
                 shareholders: {
-                    type: "array",
+                    type: 'array',
                     items: {
-                        type: "object",
+                        type: 'object',
                         properties: {
-                            shareholderId: { type: "string" },
-                            name: { type: "string" },
-                            shareholdings: { type: "array" },
+                            shareholderId: { type: 'string' },
+                            name: { type: 'string' },
+                            address: {
+                                type: 'address',
+                                description: 'DAG wallet address of record for this shareholder; the only key a verified signer can vote under.',
+                            },
+                            shareholdings: { type: 'array' },
                         },
                     },
                 },
-                totalSharesOutstanding: { type: "integer" },
+                totalSharesOutstanding: { type: 'integer' },
             },
         },
         open_proxy_period: {
-            description: "Distribute proxy materials and open proxy solicitation period",
-            required: [
-                "startDate",
-                "proxyStatementRef",
-                "formOfProxyRef",
-                "agenda",
-            ],
+            description: 'Distribute proxy materials and open proxy solicitation period',
+            required: ['startDate', 'proxyStatementRef', 'formOfProxyRef', 'agenda'],
             properties: {
-                startDate: { type: "string", format: "date" },
-                proxyStatementRef: { type: "string" },
-                formOfProxyRef: { type: "string" },
-                annualReportRef: { type: "string" },
-                agenda: { type: "array" },
+                startDate: { type: 'string', format: 'date' },
+                proxyStatementRef: { type: 'string' },
+                formOfProxyRef: { type: 'string' },
+                annualReportRef: { type: 'string' },
+                agenda: { type: 'array' },
             },
         },
         add_agenda_item: {
-            description: "Add an item to the meeting agenda (e.g., shareholder proposal)",
-            required: ["itemId", "title", "type", "voteRequired"],
+            description: 'Add an item to the meeting agenda (e.g., shareholder proposal)',
+            required: ['itemId', 'title', 'type', 'voteRequired'],
             properties: {
-                itemId: { type: "string" },
-                title: { type: "string" },
-                description: { type: "string" },
-                type: { type: "string" },
-                voteRequired: { type: "string" },
-                eligibleClasses: { type: "array", items: { type: "string" } },
-                allowCumulativeVoting: { type: "boolean", default: false },
+                itemId: { type: 'string' },
+                title: { type: 'string' },
+                description: { type: 'string' },
+                type: { type: 'string' },
+                voteRequired: { type: 'string' },
+                eligibleClasses: { type: 'array', items: { type: 'string' } },
+                allowCumulativeVoting: { type: 'boolean', default: false },
             },
         },
         open_meeting: {
-            description: "Convene the shareholder meeting",
-            required: [
-                "openedAt",
-                "chairPerson",
-                "secretaryPresent",
-                "initialQuorumCount",
-            ],
+            description: 'Convene the shareholder meeting',
+            required: ['openedAt', 'chairPerson', 'secretaryPresent', 'initialQuorumCount'],
             properties: {
-                openedAt: { type: "string", format: "date-time" },
-                chairPerson: { type: "string" },
-                secretaryPresent: { type: "string" },
-                inspectorOfElections: { type: "object" },
-                initialQuorumCount: { type: "integer" },
+                openedAt: { type: 'string', format: 'date-time' },
+                chairPerson: { type: 'string' },
+                secretaryPresent: { type: 'string' },
+                inspectorOfElections: { type: 'object' },
+                initialQuorumCount: { type: 'integer' },
             },
         },
         open_polls: {
-            description: "Open polls for voting on agenda items",
-            required: ["pollsOpenedAt"],
+            description: 'Open polls for voting on agenda items',
+            required: ['pollsOpenedAt'],
             properties: {
-                pollsOpenedAt: { type: "string", format: "date-time" },
+                pollsOpenedAt: { type: 'string', format: 'date-time' },
             },
         },
         cast_vote: {
-            description: "Record a vote from a shareholder or proxy holder",
-            required: [
-                "voteId",
-                "agendaItemId",
-                "voterId",
-                "shareholderId",
-                "shareClass",
-            ],
+            description: 'Record a vote from a shareholder or proxy holder',
+            required: ['voteId', 'agendaItemId', 'voterId', 'shareholderId', 'shareClass'],
             properties: {
-                voteId: { type: "string" },
-                agendaItemId: { type: "string" },
-                voterId: { type: "string" },
-                shareholderId: { type: "string" },
-                shareClass: { type: "string" },
-                votesFor: { type: "integer", default: 0 },
-                votesAgainst: { type: "integer", default: 0 },
-                votesAbstain: { type: "integer", default: 0 },
-                votesWithhold: { type: "integer", default: 0 },
-                cumulativeVoteAllocation: { type: "object", nullable: true },
-                viaProxy: { type: "boolean", default: false },
+                voteId: { type: 'string' },
+                agendaItemId: { type: 'string' },
+                voterId: { type: 'string' },
+                shareholderId: { type: 'string' },
+                shareClass: { type: 'string' },
+                votesFor: { type: 'integer', default: 0 },
+                votesAgainst: { type: 'integer', default: 0 },
+                votesAbstain: { type: 'integer', default: 0 },
+                votesWithhold: { type: 'integer', default: 0 },
+                cumulativeVoteAllocation: { type: 'object', nullable: true },
+                viaProxy: { type: 'boolean', default: false },
             },
         },
         close_polls: {
-            description: "Close polls and begin vote tabulation",
-            required: ["pollsClosedAt"],
+            description: 'Close polls and begin vote tabulation',
+            required: ['pollsClosedAt'],
             properties: {
-                pollsClosedAt: { type: "string", format: "date-time" },
+                pollsClosedAt: { type: 'string', format: 'date-time' },
             },
         },
         certify_results: {
-            description: "Inspector of elections certifies vote results",
-            required: ["certifiedAt", "certifiedBy", "certificateRef"],
+            description: 'Inspector of elections certifies vote results',
+            required: ['certifiedAt', 'certifiedBy', 'certificateRef'],
             properties: {
-                certifiedAt: { type: "string", format: "date-time" },
-                certifiedBy: { type: "string" },
-                certificateRef: { type: "string" },
+                certifiedAt: { type: 'string', format: 'date-time' },
+                certifiedBy: { type: 'string' },
+                certificateRef: { type: 'string' },
                 results: {
-                    type: "array",
+                    type: 'array',
                     items: {
-                        type: "object",
+                        type: 'object',
                         properties: {
-                            agendaItemId: { type: "string" },
+                            agendaItemId: { type: 'string' },
                             result: {
-                                type: "string",
-                                enum: ["APPROVED", "REJECTED"],
+                                type: 'string',
+                                enum: ['APPROVED', 'REJECTED'],
                             },
                         },
                     },
                 },
-                minutesRef: { type: "string" },
+                minutesRef: { type: 'string' },
             },
         },
         adjourn_without_action: {
-            description: "Adjourn meeting without completing agenda (e.g., quorum lost)",
-            required: ["adjournedAt", "reason"],
+            description: 'Adjourn meeting without completing agenda (e.g., quorum lost)',
+            required: ['adjournedAt', 'reason'],
             properties: {
-                adjournedAt: { type: "string", format: "date-time" },
-                reason: { type: "string" },
-                adjournedTo: { type: "string", format: "date-time", nullable: true },
+                adjournedAt: { type: 'string', format: 'date-time' },
+                reason: { type: 'string' },
+                adjournedTo: { type: 'string', format: 'date-time', nullable: true },
             },
         },
     },
     definitions: {
         CalledBy: {
-            type: "object",
+            type: 'object',
             properties: {
                 type: {
-                    type: "string",
-                    enum: ["BOARD", "SHAREHOLDERS", "COURT"],
+                    type: 'string',
+                    enum: ['BOARD', 'SHAREHOLDERS', 'COURT'],
                 },
-                resolutionRef: { type: "string", nullable: true },
-                shareholderPetitionRef: { type: "string", nullable: true },
-                courtOrderRef: { type: "string", nullable: true },
+                resolutionRef: { type: 'string', nullable: true },
+                shareholderPetitionRef: { type: 'string', nullable: true },
+                courtOrderRef: { type: 'string', nullable: true },
             },
         },
         NoticeInfo: {
-            type: "object",
+            type: 'object',
             properties: {
-                noticeSentDate: { type: "string", format: "date" },
+                noticeSentDate: { type: 'string', format: 'date' },
                 noticeMethod: {
-                    type: "string",
-                    enum: ["MAIL", "EMAIL", "ELECTRONIC_ACCESS"],
+                    type: 'string',
+                    enum: ['MAIL', 'EMAIL', 'ELECTRONIC_ACCESS'],
                 },
-                minimumNoticeDays: { type: "integer", default: 10 },
-                maximumNoticeDays: { type: "integer", default: 60 },
+                minimumNoticeDays: { type: 'integer', default: 10 },
+                maximumNoticeDays: { type: 'integer', default: 60 },
             },
         },
         RecordDate: {
-            type: "object",
+            type: 'object',
             nullable: true,
             properties: {
-                date: { type: "string", format: "date" },
-                setByBoardOn: { type: "string", format: "date" },
-                resolutionRef: { type: "string" },
+                date: { type: 'string', format: 'date' },
+                setByBoardOn: { type: 'string', format: 'date' },
+                resolutionRef: { type: 'string' },
             },
         },
         EligibleVoter: {
-            type: "object",
+            type: 'object',
             properties: {
-                shareholderId: { type: "string" },
-                name: { type: "string" },
+                shareholderId: { type: 'string' },
+                name: { type: 'string' },
+                address: {
+                    type: 'address',
+                    description: 'State-pinned DAG wallet address of record; cast_vote requires this address ∈ proofs[].address.',
+                },
                 shareholdings: {
-                    type: "array",
+                    type: 'array',
                     items: {
-                        type: "object",
+                        type: 'object',
                         properties: {
-                            shareClass: { type: "string" },
-                            shares: { type: "integer" },
+                            shareClass: { type: 'string' },
+                            shares: { type: 'integer' },
                             votes: {
-                                type: "integer",
-                                description: "Votes this holding represents",
+                                type: 'integer',
+                                description: 'Votes this holding represents',
                             },
                         },
                     },
                 },
-                totalVotes: { type: "integer" },
+                totalVotes: { type: 'integer' },
                 proxyGrantedTo: {
-                    type: "string",
+                    type: 'string',
                     nullable: true,
-                    description: "Proxy holder ID if proxied",
+                    description: 'Proxy holder ID if proxied',
                 },
-                hasVoted: { type: "boolean", default: false },
+                hasVoted: { type: 'boolean', default: false },
             },
         },
         QuorumRequirements: {
-            type: "object",
+            type: 'object',
             properties: {
                 type: {
-                    type: "string",
-                    enum: ["SHARES_REPRESENTED", "SHARES_OUTSTANDING"],
+                    type: 'string',
+                    enum: ['SHARES_REPRESENTED', 'SHARES_OUTSTANDING'],
                 },
                 threshold: {
-                    type: "number",
+                    type: 'number',
                     default: 0.5,
-                    description: "Fraction required for quorum",
+                    description: 'Fraction required for quorum',
                 },
-                sharesRequired: { type: "integer" },
-                sharesRepresented: { type: "integer", default: 0 },
-                quorumMet: { type: "boolean", default: false },
+                sharesRequired: { type: 'integer' },
+                sharesRepresented: { type: 'integer', default: 0 },
+                quorumMet: { type: 'boolean', default: false },
             },
         },
         AgendaItem: {
-            type: "object",
+            type: 'object',
             properties: {
-                itemId: { type: "string" },
-                itemNumber: { type: "integer" },
-                title: { type: "string" },
-                description: { type: "string" },
+                itemId: { type: 'string' },
+                itemNumber: { type: 'integer' },
+                title: { type: 'string' },
+                description: { type: 'string' },
                 type: {
-                    type: "string",
+                    type: 'string',
                     enum: [
-                        "DIRECTOR_ELECTION",
-                        "AUDITOR_RATIFICATION",
-                        "SAY_ON_PAY",
-                        "CHARTER_AMENDMENT",
-                        "MERGER",
-                        "STOCK_PLAN",
-                        "SHAREHOLDER_PROPOSAL",
-                        "OTHER",
+                        'DIRECTOR_ELECTION',
+                        'AUDITOR_RATIFICATION',
+                        'SAY_ON_PAY',
+                        'CHARTER_AMENDMENT',
+                        'MERGER',
+                        'STOCK_PLAN',
+                        'SHAREHOLDER_PROPOSAL',
+                        'OTHER',
                     ],
                 },
                 voteRequired: {
-                    type: "string",
-                    enum: [
-                        "PLURALITY",
-                        "MAJORITY_CAST",
-                        "MAJORITY_OUTSTANDING",
-                        "SUPERMAJORITY",
-                        "UNANIMOUS",
-                    ],
-                    description: "Vote threshold for approval",
+                    type: 'string',
+                    enum: ['PLURALITY', 'MAJORITY_CAST', 'MAJORITY_OUTSTANDING', 'SUPERMAJORITY', 'UNANIMOUS'],
+                    description: 'Vote threshold for approval',
                 },
-                supermajorityThreshold: { type: "number", nullable: true },
+                supermajorityThreshold: { type: 'number', nullable: true },
                 eligibleClasses: {
-                    type: "array",
-                    items: { type: "string" },
-                    description: "Share classes that can vote on this item",
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'Share classes that can vote on this item',
                 },
                 allowCumulativeVoting: {
-                    type: "boolean",
+                    type: 'boolean',
                     default: false,
-                    description: "For director elections",
+                    description: 'For director elections',
                 },
                 status: {
-                    type: "string",
-                    enum: [
-                        "PENDING",
-                        "VOTING",
-                        "CLOSED",
-                        "APPROVED",
-                        "REJECTED",
-                    ],
+                    type: 'string',
+                    enum: ['PENDING', 'VOTING', 'CLOSED', 'APPROVED', 'REJECTED'],
                 },
             },
         },
         ProxyPeriod: {
-            type: "object",
+            type: 'object',
             nullable: true,
             properties: {
-                startDate: { type: "string", format: "date" },
+                startDate: { type: 'string', format: 'date' },
                 endDate: {
-                    type: "string",
-                    format: "date-time",
-                    description: "Usually meeting start time",
+                    type: 'string',
+                    format: 'date-time',
+                    description: 'Usually meeting start time',
                 },
                 proxyMaterials: {
-                    type: "object",
+                    type: 'object',
                     properties: {
-                        proxyStatementRef: { type: "string" },
-                        formOfProxyRef: { type: "string" },
-                        annualReportRef: { type: "string", nullable: true },
+                        proxyStatementRef: { type: 'string' },
+                        formOfProxyRef: { type: 'string' },
+                        annualReportRef: { type: 'string', nullable: true },
                     },
                 },
             },
         },
         Vote: {
-            type: "object",
+            type: 'object',
             properties: {
-                voteId: { type: "string" },
-                agendaItemId: { type: "string" },
+                voteId: { type: 'string' },
+                agendaItemId: { type: 'string' },
                 voterId: {
-                    type: "string",
-                    description: "Shareholder or proxy holder ID",
+                    type: 'string',
+                    description: 'Shareholder or proxy holder ID',
                 },
-                shareholderId: { type: "string", description: "Beneficial owner" },
-                shareClass: { type: "string" },
-                votesFor: { type: "integer", default: 0 },
-                votesAgainst: { type: "integer", default: 0 },
-                votesAbstain: { type: "integer", default: 0 },
+                shareholderId: { type: 'string', description: 'Beneficial owner' },
+                shareClass: { type: 'string' },
+                votesFor: { type: 'integer', default: 0 },
+                votesAgainst: { type: 'integer', default: 0 },
+                votesAbstain: { type: 'integer', default: 0 },
                 votesWithhold: {
-                    type: "integer",
+                    type: 'integer',
                     default: 0,
-                    description: "For director elections",
+                    description: 'For director elections',
                 },
                 cumulativeVoteAllocation: {
-                    type: "object",
-                    additionalProperties: { type: "integer" },
+                    type: 'object',
+                    additionalProperties: { type: 'integer' },
                     nullable: true,
-                    description: "For cumulative voting: candidate ID -> votes allocated",
+                    description: 'For cumulative voting: candidate ID -> votes allocated',
                 },
-                viaProxy: { type: "boolean", default: false },
-                timestamp: { type: "string", format: "date-time" },
+                viaProxy: { type: 'boolean', default: false },
+                timestamp: { type: 'string', format: 'date-time' },
             },
         },
         VoteTally: {
-            type: "object",
+            type: 'object',
             properties: {
-                agendaItemId: { type: "string" },
-                forVotes: { type: "integer", default: 0 },
-                againstVotes: { type: "integer", default: 0 },
-                abstainVotes: { type: "integer", default: 0 },
-                withholdVotes: { type: "integer", default: 0 },
-                brokerNonVotes: { type: "integer", default: 0 },
+                agendaItemId: { type: 'string' },
+                forVotes: { type: 'integer', default: 0 },
+                againstVotes: { type: 'integer', default: 0 },
+                abstainVotes: { type: 'integer', default: 0 },
+                withholdVotes: { type: 'integer', default: 0 },
+                brokerNonVotes: { type: 'integer', default: 0 },
                 candidateVotes: {
-                    type: "object",
-                    additionalProperties: { type: "integer" },
+                    type: 'object',
+                    additionalProperties: { type: 'integer' },
                     nullable: true,
-                    description: "For director elections: candidate ID -> total votes",
+                    description: 'For director elections: candidate ID -> total votes',
                 },
                 result: {
-                    type: "string",
-                    enum: ["APPROVED", "REJECTED", "PENDING"],
+                    type: 'string',
+                    enum: ['APPROVED', 'REJECTED', 'PENDING'],
                 },
-                certified: { type: "boolean", default: false },
+                certified: { type: 'boolean', default: false },
             },
         },
         Inspector: {
-            type: "object",
+            type: 'object',
             nullable: true,
             properties: {
-                name: { type: "string" },
-                company: { type: "string", nullable: true },
-                appointedBy: { type: "string" },
-                appointmentDate: { type: "string", format: "date" },
+                name: { type: 'string' },
+                company: { type: 'string', nullable: true },
+                appointedBy: { type: 'string' },
+                appointmentDate: { type: 'string', format: 'date' },
             },
         },
         SessionInfo: {
-            type: "object",
+            type: 'object',
             nullable: true,
             properties: {
-                openedAt: { type: "string", format: "date-time" },
-                chairPerson: { type: "string" },
-                secretaryPresent: { type: "string" },
-                pollsOpenedAt: { type: "string", format: "date-time", nullable: true },
-                pollsClosedAt: { type: "string", format: "date-time", nullable: true },
-                adjournedAt: { type: "string", format: "date-time", nullable: true },
-                minutesRef: { type: "string", nullable: true },
+                openedAt: { type: 'string', format: 'date-time' },
+                chairPerson: { type: 'string' },
+                secretaryPresent: { type: 'string' },
+                pollsOpenedAt: { type: 'string', format: 'date-time', nullable: true },
+                pollsClosedAt: { type: 'string', format: 'date-time', nullable: true },
+                adjournedAt: { type: 'string', format: 'date-time', nullable: true },
+                minutesRef: { type: 'string', nullable: true },
             },
         },
         Certification: {
-            type: "object",
+            type: 'object',
             nullable: true,
             properties: {
-                certifiedAt: { type: "string", format: "date-time" },
-                certifiedBy: { type: "string" },
-                certificateRef: { type: "string" },
+                certifiedAt: { type: 'string', format: 'date-time' },
+                certifiedBy: { type: 'string' },
+                certificateRef: { type: 'string' },
             },
         },
     },
     states: {
         SCHEDULED: {
-            id: "SCHEDULED",
+            id: 'SCHEDULED',
             isFinal: false,
-            description: "Meeting has been scheduled but record date not yet set",
+            description: 'Meeting has been scheduled but record date not yet set',
         },
         RECORD_DATE_SET: {
-            id: "RECORD_DATE_SET",
+            id: 'RECORD_DATE_SET',
             isFinal: false,
-            description: "Record date established; eligible shareholders determined",
+            description: 'Record date established; eligible shareholders determined',
         },
         PROXY_PERIOD: {
-            id: "PROXY_PERIOD",
+            id: 'PROXY_PERIOD',
             isFinal: false,
-            description: "Proxy materials distributed; shareholders may submit proxies",
+            description: 'Proxy materials distributed; shareholders may submit proxies',
         },
         IN_SESSION: {
-            id: "IN_SESSION",
+            id: 'IN_SESSION',
             isFinal: false,
-            description: "Meeting is convened and in progress",
+            description: 'Meeting is convened and in progress',
         },
         VOTING: {
-            id: "VOTING",
+            id: 'VOTING',
             isFinal: false,
-            description: "Polls are open for voting on agenda items",
+            description: 'Polls are open for voting on agenda items',
         },
         CLOSED: {
-            id: "CLOSED",
+            id: 'CLOSED',
             isFinal: true,
-            description: "Meeting concluded; results certified",
+            description: 'Meeting concluded; results certified',
         },
     },
-    initialState: "SCHEDULED",
+    initialState: 'SCHEDULED',
     transitions: [
         // Initial creation transitions (from: null means creation)
-        // schedule_annual -> SCHEDULED
+        // SCHEDULED -> SCHEDULED (propose_schedule_annual) — phase 1 (#24): bind the executing board-resolution
+        // fiber and record the pending meeting, so the next transition can read the resolution's state.
         {
-            from: "SCHEDULED",
-            to: "SCHEDULED",
-            eventName: "schedule_annual",
-            guard: { "==": [1, 1] },
-            dependencies: [
-                {
-                    machine: "corporate-resolution",
-                    instanceRef: { var: "event.boardResolutionRef" },
-                    requiredState: "EXECUTED",
-                },
-            ],
+            from: 'SCHEDULED',
+            to: 'SCHEDULED',
+            eventName: 'propose_schedule_annual',
+            guard: { '==': [1, 1] },
+            effect: {
+                merge: [
+                    { var: 'state' },
+                    {
+                        pendingschedule_annual: {
+                            meetingId: { var: 'event.meetingId' },
+                            entityId: { var: 'event.entityId' },
+                            fiscalYear: { var: 'event.fiscalYear' },
+                            scheduledDate: { var: 'event.scheduledDate' },
+                            location: { var: 'event.location' },
+                            ref: { var: 'event.boardResolutionRef' },
+                            proposedAt: { var: '$ordinal' },
+                        },
+                    },
+                    // bind the resolution fiber so schedule_annual can assert its state next transition
+                    addDependency({ var: 'event.boardResolutionRef' }),
+                ],
+            },
+            dependencies: [],
+        },
+        // SCHEDULED -> SCHEDULED (schedule_annual) — phase 2 (#24): execute once the bound board resolution is
+        // EXECUTED. depInState replaces the dropped object-form dependency (which silently never gated).
+        {
+            from: 'SCHEDULED',
+            to: 'SCHEDULED',
+            eventName: 'schedule_annual',
+            guard: {
+                and: [
+                    // the proposal must target this meeting, and its bound resolution must be EXECUTED
+                    {
+                        '==': [{ var: 'state.pendingschedule_annual.meetingId' }, { var: 'event.meetingId' }],
+                    },
+                    depInState('state.pendingschedule_annual.ref', 'EXECUTED'),
+                ],
+            },
             effect: {
                 merge: [
-                    { var: "state" },
+                    { var: 'state' },
                     {
-                        meetingId: { var: "event.meetingId" },
-                        entityId: { var: "event.entityId" },
-                        meetingType: "ANNUAL",
-                        fiscalYear: { var: "event.fiscalYear" },
-                        scheduledDate: { var: "event.scheduledDate" },
-                        location: { var: "event.location" },
+                        meetingId: { var: 'event.meetingId' },
+                        entityId: { var: 'event.entityId' },
+                        meetingType: 'ANNUAL',
+                        fiscalYear: { var: 'event.fiscalYear' },
+                        scheduledDate: { var: 'event.scheduledDate' },
+                        location: { var: 'event.location' },
                         calledBy: {
-                            type: "BOARD",
-                            resolutionRef: { var: "event.boardResolutionRef" },
+                            type: 'BOARD',
+                            resolutionRef: { var: 'state.pendingschedule_annual.ref' },
                         },
+                        // clear the consumed proposal
+                        pendingschedule_annual: null,
+                    },
+                    {
+                        _emit: [{ name: 'SHAREHOLDER_MEETING_SCHEDULED', data: { var: 'event' }, destination: 'external' }],
                     },
                 ],
             },
-            emits: ["SHAREHOLDER_MEETING_SCHEDULED"],
+            dependencies: [],
         },
         // schedule_special -> SCHEDULED
         {
-            from: "SCHEDULED",
-            to: "SCHEDULED",
-            eventName: "schedule_special",
-            guard: { "==": [1, 1] },
+            from: 'SCHEDULED',
+            to: 'SCHEDULED',
+            eventName: 'schedule_special',
+            guard: { '==': [1, 1] },
             effect: {
                 merge: [
-                    { var: "state" },
+                    { var: 'state' },
                     {
-                        meetingId: { var: "event.meetingId" },
-                        entityId: { var: "event.entityId" },
-                        meetingType: "SPECIAL",
-                        scheduledDate: { var: "event.scheduledDate" },
+                        meetingId: { var: 'event.meetingId' },
+                        entityId: { var: 'event.entityId' },
+                        meetingType: 'SPECIAL',
+                        scheduledDate: { var: 'event.scheduledDate' },
                         calledBy: {
-                            type: { var: "event.calledByType" },
+                            type: { var: 'event.calledByType' },
                         },
                     },
+                    {
+                        _emit: [{ name: 'SPECIAL_MEETING_SCHEDULED', data: { var: 'event' }, destination: 'external' }],
+                    },
                 ],
             },
-            emits: ["SPECIAL_MEETING_SCHEDULED"],
         },
         // SCHEDULED -> RECORD_DATE_SET
         {
-            from: "SCHEDULED",
-            to: "RECORD_DATE_SET",
-            eventName: "set_record_date",
-            guard: { "==": [1, 1] }, // validRecordDateTiming simplified
+            from: 'SCHEDULED',
+            to: 'RECORD_DATE_SET',
+            eventName: 'set_record_date',
+            guard: { '==': [1, 1] }, // validRecordDateTiming simplified
             effect: {
                 merge: [
-                    { var: "state" },
+                    { var: 'state' },
                     {
-                        status: "RECORD_DATE_SET",
+                        status: 'RECORD_DATE_SET',
                         recordDate: {
-                            date: { var: "event.recordDate" },
-                            setByBoardOn: { var: "$timestamp" },
-                            resolutionRef: { var: "event.resolutionRef" },
+                            date: { var: 'event.recordDate' },
+                            setByBoardOn: { var: '$ordinal' },
+                            resolutionRef: { var: 'event.resolutionRef' },
                         },
                     },
+                    {
+                        _emit: [{ name: 'RECORD_DATE_SET', data: { var: 'event' }, destination: 'external' }],
+                    },
                 ],
             },
-            emits: ["RECORD_DATE_SET"],
         },
         // RECORD_DATE_SET -> RECORD_DATE_SET (register_eligible_shareholders)
         {
-            from: "RECORD_DATE_SET",
-            to: "RECORD_DATE_SET",
-            eventName: "register_eligible_shareholders",
-            guard: { "==": [1, 1] },
+            from: 'RECORD_DATE_SET',
+            to: 'RECORD_DATE_SET',
+            eventName: 'register_eligible_shareholders',
+            // authority gate — only the pinned registrar may set the roster of record; an identity role attestation (ISSUER/BOARD_MEMBER/...) layers on additively when the identity registry lands (docs/design/app-hardening-identity-integration.md §4.2)
+            guard: signerIsParty('state.registrar'),
             effect: {
                 merge: [
-                    { var: "state" },
+                    { var: 'state' },
                     {
-                        eligibleVoters: { var: "event.shareholders" },
+                        eligibleVoters: { var: 'event.shareholders' },
                         quorumRequirements: {
                             merge: [
-                                { var: "state.quorumRequirements" },
+                                { var: 'state.quorumRequirements' },
                                 {
                                     sharesRequired: {
-                                        "*": [{ var: "event.totalSharesOutstanding" }, 0.5],
+                                        '*': [{ var: 'event.totalSharesOutstanding' }, 0.5],
                                     },
                                 },
                             ],
@@ -704,62 +726,61 @@ export const corpShareholdersDef = defineFiberApp({
         },
         // RECORD_DATE_SET -> PROXY_PERIOD
         {
-            from: "RECORD_DATE_SET",
-            to: "PROXY_PERIOD",
-            eventName: "open_proxy_period",
-            guard: { "==": [1, 1] },
+            from: 'RECORD_DATE_SET',
+            to: 'PROXY_PERIOD',
+            eventName: 'open_proxy_period',
+            guard: { '==': [1, 1] },
             effect: {
                 merge: [
-                    { var: "state" },
+                    { var: 'state' },
                     {
-                        status: "PROXY_PERIOD",
+                        status: 'PROXY_PERIOD',
                         proxyPeriod: {
-                            startDate: { var: "event.startDate" },
-                            endDate: { var: "state.scheduledDate" },
+                            startDate: { var: 'event.startDate' },
+                            endDate: { var: 'state.scheduledDate' },
                             proxyMaterials: {
-                                proxyStatementRef: { var: "event.proxyStatementRef" },
-                                formOfProxyRef: { var: "event.formOfProxyRef" },
-                                annualReportRef: { var: "event.annualReportRef" },
+                                proxyStatementRef: { var: 'event.proxyStatementRef' },
+                                formOfProxyRef: { var: 'event.formOfProxyRef' },
+                                annualReportRef: { var: 'event.annualReportRef' },
                             },
                         },
-                        agenda: { var: "event.agenda" },
+                        agenda: { var: 'event.agenda' },
                         noticeInfo: {
-                            merge: [
-                                { var: "state.noticeInfo" },
-                                { noticeSentDate: { var: "event.startDate" } },
-                            ],
+                            merge: [{ var: 'state.noticeInfo' }, { noticeSentDate: { var: 'event.startDate' } }],
                         },
                     },
+                    {
+                        _emit: [{ name: 'PROXY_PERIOD_OPENED', data: { var: 'event' }, destination: 'external' }],
+                    },
                 ],
             },
-            emits: ["PROXY_PERIOD_OPENED"],
         },
         // add_agenda_item (can be from multiple states)
         {
-            from: "SCHEDULED",
-            to: "SCHEDULED",
-            eventName: "add_agenda_item",
-            guard: { "==": [1, 1] },
+            from: 'SCHEDULED',
+            to: 'SCHEDULED',
+            eventName: 'add_agenda_item',
+            guard: { '==': [1, 1] },
             effect: {
                 merge: [
-                    { var: "state" },
+                    { var: 'state' },
                     {
                         agenda: {
-                            cat: [
-                                { var: "state.agenda" },
+                            merge: [
+                                { var: 'state.agenda' },
                                 [
                                     {
-                                        itemId: { var: "event.itemId" },
-                                        itemNumber: { "+": [{ var: "state.agenda.length" }, 1] },
-                                        title: { var: "event.title" },
-                                        description: { var: "event.description" },
-                                        type: { var: "event.type" },
-                                        voteRequired: { var: "event.voteRequired" },
-                                        eligibleClasses: { var: "event.eligibleClasses" },
+                                        itemId: { var: 'event.itemId' },
+                                        itemNumber: { '+': [{ length: [{ var: 'state.agenda' }] }, 1] },
+                                        title: { var: 'event.title' },
+                                        description: { var: 'event.description' },
+                                        type: { var: 'event.type' },
+                                        voteRequired: { var: 'event.voteRequired' },
+                                        eligibleClasses: { var: 'event.eligibleClasses' },
                                         allowCumulativeVoting: {
-                                            var: "event.allowCumulativeVoting",
+                                            var: 'event.allowCumulativeVoting',
                                         },
-                                        status: "PENDING",
+                                        status: 'PENDING',
                                     },
                                 ],
                             ],
@@ -769,30 +790,30 @@ export const corpShareholdersDef = defineFiberApp({
             },
         },
         {
-            from: "RECORD_DATE_SET",
-            to: "RECORD_DATE_SET",
-            eventName: "add_agenda_item",
-            guard: { "==": [1, 1] },
+            from: 'RECORD_DATE_SET',
+            to: 'RECORD_DATE_SET',
+            eventName: 'add_agenda_item',
+            guard: { '==': [1, 1] },
             effect: {
                 merge: [
-                    { var: "state" },
+                    { var: 'state' },
                     {
                         agenda: {
-                            cat: [
-                                { var: "state.agenda" },
+                            merge: [
+                                { var: 'state.agenda' },
                                 [
                                     {
-                                        itemId: { var: "event.itemId" },
-                                        itemNumber: { "+": [{ var: "state.agenda.length" }, 1] },
-                                        title: { var: "event.title" },
-                                        description: { var: "event.description" },
-                                        type: { var: "event.type" },
-                                        voteRequired: { var: "event.voteRequired" },
-                                        eligibleClasses: { var: "event.eligibleClasses" },
+                                        itemId: { var: 'event.itemId' },
+                                        itemNumber: { '+': [{ length: [{ var: 'state.agenda' }] }, 1] },
+                                        title: { var: 'event.title' },
+                                        description: { var: 'event.description' },
+                                        type: { var: 'event.type' },
+                                        voteRequired: { var: 'event.voteRequired' },
+                                        eligibleClasses: { var: 'event.eligibleClasses' },
                                         allowCumulativeVoting: {
-                                            var: "event.allowCumulativeVoting",
+                                            var: 'event.allowCumulativeVoting',
                                         },
-                                        status: "PENDING",
+                                        status: 'PENDING',
                                     },
                                 ],
                             ],
@@ -802,30 +823,30 @@ export const corpShareholdersDef = defineFiberApp({
             },
         },
         {
-            from: "PROXY_PERIOD",
-            to: "PROXY_PERIOD",
-            eventName: "add_agenda_item",
-            guard: { "==": [1, 1] },
+            from: 'PROXY_PERIOD',
+            to: 'PROXY_PERIOD',
+            eventName: 'add_agenda_item',
+            guard: { '==': [1, 1] },
             effect: {
                 merge: [
-                    { var: "state" },
+                    { var: 'state' },
                     {
                         agenda: {
-                            cat: [
-                                { var: "state.agenda" },
+                            merge: [
+                                { var: 'state.agenda' },
                                 [
                                     {
-                                        itemId: { var: "event.itemId" },
-                                        itemNumber: { "+": [{ var: "state.agenda.length" }, 1] },
-                                        title: { var: "event.title" },
-                                        description: { var: "event.description" },
-                                        type: { var: "event.type" },
-                                        voteRequired: { var: "event.voteRequired" },
-                                        eligibleClasses: { var: "event.eligibleClasses" },
+                                        itemId: { var: 'event.itemId' },
+                                        itemNumber: { '+': [{ length: [{ var: 'state.agenda' }] }, 1] },
+                                        title: { var: 'event.title' },
+                                        description: { var: 'event.description' },
+                                        type: { var: 'event.type' },
+                                        voteRequired: { var: 'event.voteRequired' },
+                                        eligibleClasses: { var: 'event.eligibleClasses' },
                                         allowCumulativeVoting: {
-                                            var: "event.allowCumulativeVoting",
+                                            var: 'event.allowCumulativeVoting',
                                         },
-                                        status: "PENDING",
+                                        status: 'PENDING',
                                     },
                                 ],
                             ],
@@ -836,62 +857,58 @@ export const corpShareholdersDef = defineFiberApp({
         },
         // PROXY_PERIOD -> IN_SESSION
         {
-            from: "PROXY_PERIOD",
-            to: "IN_SESSION",
-            eventName: "open_meeting",
+            from: 'PROXY_PERIOD',
+            to: 'IN_SESSION',
+            eventName: 'open_meeting',
             guard: {
-                ">=": [
-                    { var: "event.initialQuorumCount" },
-                    { var: "state.quorumRequirements.sharesRequired" },
-                ],
+                '>=': [{ var: 'event.initialQuorumCount' }, { var: 'state.quorumRequirements.sharesRequired' }],
             },
             effect: {
                 merge: [
-                    { var: "state" },
+                    { var: 'state' },
                     {
-                        status: "IN_SESSION",
+                        status: 'IN_SESSION',
                         sessionInfo: {
-                            openedAt: { var: "event.openedAt" },
-                            chairPerson: { var: "event.chairPerson" },
-                            secretaryPresent: { var: "event.secretaryPresent" },
+                            openedAt: { var: 'event.openedAt' },
+                            chairPerson: { var: 'event.chairPerson' },
+                            secretaryPresent: { var: 'event.secretaryPresent' },
                         },
-                        inspectorOfElections: { var: "event.inspectorOfElections" },
+                        inspectorOfElections: { var: 'event.inspectorOfElections' },
                         quorumRequirements: {
                             merge: [
-                                { var: "state.quorumRequirements" },
+                                { var: 'state.quorumRequirements' },
                                 {
-                                    sharesRepresented: { var: "event.initialQuorumCount" },
+                                    sharesRepresented: { var: 'event.initialQuorumCount' },
                                     quorumMet: true,
                                 },
                             ],
                         },
                     },
+                    {
+                        _emit: [{ name: 'SHAREHOLDER_MEETING_OPENED', data: { var: 'event' }, destination: 'external' }],
+                    },
                 ],
             },
-            emits: ["SHAREHOLDER_MEETING_OPENED"],
         },
         // IN_SESSION -> VOTING
         {
-            from: "IN_SESSION",
-            to: "VOTING",
-            eventName: "open_polls",
-            guard: { "==": [1, 1] },
+            from: 'IN_SESSION',
+            to: 'VOTING',
+            eventName: 'open_polls',
+            guard: { '==': [1, 1] },
             effect: {
                 merge: [
-                    { var: "state" },
+                    { var: 'state' },
                     {
-                        status: "VOTING",
+                        status: 'VOTING',
                         sessionInfo: {
-                            merge: [
-                                { var: "state.sessionInfo" },
-                                { pollsOpenedAt: { var: "event.pollsOpenedAt" } },
-                            ],
+                            merge: [{ var: 'state.sessionInfo' }, { pollsOpenedAt: { var: 'event.pollsOpenedAt' } }],
                         },
                         agenda: {
                             map: [
-                                { var: "state.agenda" },
+                                { var: 'state.agenda' },
                                 {
-                                    merge: [{ var: "" }, { status: "VOTING" }],
+                                    merge: [{ var: '' }, { status: 'VOTING' }],
                                 },
                             ],
                         },
@@ -901,39 +918,38 @@ export const corpShareholdersDef = defineFiberApp({
         },
         // VOTING -> VOTING (cast_vote)
         {
-            from: "VOTING",
-            to: "VOTING",
-            eventName: "cast_vote",
+            from: 'VOTING',
+            to: 'VOTING',
+            eventName: 'cast_vote',
+            // authority gate — the roster entry identified by event.shareholderId must carry an address that signed (address ∈ proofs[].address), so the recorded shareholderId is provably the matched entry's, not a forged one; an identity attestation layers on additively when the identity registry lands (docs/design/app-hardening-identity-integration.md §4.2)
             guard: {
                 and: [
                     {
                         some: [
-                            { var: "state.eligibleVoters" },
+                            { var: 'state.eligibleVoters' },
                             {
-                                "==": [
-                                    { var: ".shareholderId" },
-                                    { var: "event.shareholderId" },
+                                and: [
+                                    {
+                                        '==': [{ var: 'shareholderId' }, { var: 'event.shareholderId' }],
+                                    },
+                                    {
+                                        in: [{ var: 'address' }, { map: [{ var: 'proofs' }, { var: 'address' }] }],
+                                    },
                                 ],
                             },
                         ],
                     },
                     {
-                        "!": {
+                        '!': {
                             some: [
-                                { var: "state.votes" },
+                                { var: 'state.votes' },
                                 {
                                     and: [
                                         {
-                                            "==": [
-                                                { var: ".shareholderId" },
-                                                { var: "event.shareholderId" },
-                                            ],
+                                            '==': [{ var: 'shareholderId' }, { var: 'event.shareholderId' }],
                                         },
                                         {
-                                            "==": [
-                                                { var: ".agendaItemId" },
-                                                { var: "event.agendaItemId" },
-                                            ],
+                                            '==': [{ var: 'agendaItemId' }, { var: 'event.agendaItemId' }],
                                         },
                                     ],
                                 },
@@ -944,46 +960,43 @@ export const corpShareholdersDef = defineFiberApp({
             },
             effect: {
                 merge: [
-                    { var: "state" },
+                    { var: 'state' },
                     {
                         votes: {
-                            cat: [
-                                { var: "state.votes" },
+                            merge: [
+                                { var: 'state.votes' },
                                 [
                                     {
-                                        voteId: { var: "event.voteId" },
-                                        agendaItemId: { var: "event.agendaItemId" },
-                                        voterId: { var: "event.voterId" },
-                                        shareholderId: { var: "event.shareholderId" },
-                                        shareClass: { var: "event.shareClass" },
-                                        votesFor: { var: "event.votesFor" },
-                                        votesAgainst: { var: "event.votesAgainst" },
-                                        votesAbstain: { var: "event.votesAbstain" },
-                                        votesWithhold: { var: "event.votesWithhold" },
+                                        voteId: { var: 'event.voteId' },
+                                        agendaItemId: { var: 'event.agendaItemId' },
+                                        voterId: { var: 'event.voterId' },
+                                        shareholderId: { var: 'event.shareholderId' },
+                                        shareClass: { var: 'event.shareClass' },
+                                        votesFor: { var: 'event.votesFor' },
+                                        votesAgainst: { var: 'event.votesAgainst' },
+                                        votesAbstain: { var: 'event.votesAbstain' },
+                                        votesWithhold: { var: 'event.votesWithhold' },
                                         cumulativeVoteAllocation: {
-                                            var: "event.cumulativeVoteAllocation",
+                                            var: 'event.cumulativeVoteAllocation',
                                         },
-                                        viaProxy: { var: "event.viaProxy" },
-                                        timestamp: { var: "$timestamp" },
+                                        viaProxy: { var: 'event.viaProxy' },
+                                        timestamp: { var: '$ordinal' },
                                     },
                                 ],
                             ],
                         },
                         eligibleVoters: {
                             map: [
-                                { var: "state.eligibleVoters" },
+                                { var: 'state.eligibleVoters' },
                                 {
                                     if: [
                                         {
-                                            "==": [
-                                                { var: ".shareholderId" },
-                                                { var: "event.shareholderId" },
-                                            ],
+                                            '==': [{ var: 'shareholderId' }, { var: 'event.shareholderId' }],
                                         },
                                         {
-                                            merge: [{ var: "" }, { hasVoted: true }],
+                                            merge: [{ var: '' }, { hasVoted: true }],
                                         },
-                                        { var: "" },
+                                        { var: '' },
                                     ],
                                 },
                             ],
@@ -994,26 +1007,23 @@ export const corpShareholdersDef = defineFiberApp({
         },
         // VOTING -> IN_SESSION (close_polls)
         {
-            from: "VOTING",
-            to: "IN_SESSION",
-            eventName: "close_polls",
-            guard: { "==": [1, 1] },
+            from: 'VOTING',
+            to: 'IN_SESSION',
+            eventName: 'close_polls',
+            guard: { '==': [1, 1] },
             effect: {
                 merge: [
-                    { var: "state" },
+                    { var: 'state' },
                     {
-                        status: "IN_SESSION",
+                        status: 'IN_SESSION',
                         sessionInfo: {
-                            merge: [
-                                { var: "state.sessionInfo" },
-                                { pollsClosedAt: { var: "event.pollsClosedAt" } },
-                            ],
+                            merge: [{ var: 'state.sessionInfo' }, { pollsClosedAt: { var: 'event.pollsClosedAt' } }],
                         },
                         agenda: {
                             map: [
-                                { var: "state.agenda" },
+                                { var: 'state.agenda' },
                                 {
-                                    merge: [{ var: "" }, { status: "CLOSED" }],
+                                    merge: [{ var: '' }, { status: 'CLOSED' }],
                                 },
                             ],
                         },
@@ -1023,77 +1033,77 @@ export const corpShareholdersDef = defineFiberApp({
         },
         // IN_SESSION -> CLOSED (certify_results)
         {
-            from: "IN_SESSION",
-            to: "CLOSED",
-            eventName: "certify_results",
-            guard: { "==": [1, 1] },
+            from: 'IN_SESSION',
+            to: 'CLOSED',
+            eventName: 'certify_results',
+            guard: { '==': [1, 1] },
             effect: {
                 merge: [
-                    { var: "state" },
+                    { var: 'state' },
                     {
-                        status: "CLOSED",
+                        status: 'CLOSED',
                         certification: {
-                            certifiedAt: { var: "event.certifiedAt" },
-                            certifiedBy: { var: "event.certifiedBy" },
-                            certificateRef: { var: "event.certificateRef" },
+                            certifiedAt: { var: 'event.certifiedAt' },
+                            certifiedBy: { var: 'event.certifiedBy' },
+                            certificateRef: { var: 'event.certificateRef' },
                         },
                         sessionInfo: {
                             merge: [
-                                { var: "state.sessionInfo" },
+                                { var: 'state.sessionInfo' },
                                 {
-                                    adjournedAt: { var: "event.certifiedAt" },
-                                    minutesRef: { var: "event.minutesRef" },
+                                    adjournedAt: { var: 'event.certifiedAt' },
+                                    minutesRef: { var: 'event.minutesRef' },
                                 },
                             ],
                         },
                     },
+                    {
+                        _emit: [{ name: 'MEETING_RESULTS_CERTIFIED', data: { var: 'event' }, destination: 'external' }],
+                    },
                 ],
             },
-            emits: ["MEETING_RESULTS_CERTIFIED"],
         },
         // IN_SESSION -> CLOSED (adjourn_without_action)
         {
-            from: "IN_SESSION",
-            to: "CLOSED",
-            eventName: "adjourn_without_action",
-            guard: { "==": [1, 1] },
+            from: 'IN_SESSION',
+            to: 'CLOSED',
+            eventName: 'adjourn_without_action',
+            guard: { '==': [1, 1] },
             effect: {
                 merge: [
-                    { var: "state" },
+                    { var: 'state' },
                     {
-                        status: "CLOSED",
+                        status: 'CLOSED',
                         sessionInfo: {
-                            merge: [
-                                { var: "state.sessionInfo" },
-                                { adjournedAt: { var: "event.adjournedAt" } },
-                            ],
+                            merge: [{ var: 'state.sessionInfo' }, { adjournedAt: { var: 'event.adjournedAt' } }],
                         },
                     },
+                    {
+                        _emit: [{ name: 'MEETING_ADJOURNED', data: { var: 'event' }, destination: 'external' }],
+                    },
                 ],
             },
-            emits: ["MEETING_ADJOURNED"],
         },
         // VOTING -> CLOSED (adjourn_without_action)
         {
-            from: "VOTING",
-            to: "CLOSED",
-            eventName: "adjourn_without_action",
-            guard: { "==": [1, 1] },
+            from: 'VOTING',
+            to: 'CLOSED',
+            eventName: 'adjourn_without_action',
+            guard: { '==': [1, 1] },
             effect: {
                 merge: [
-                    { var: "state" },
+                    { var: 'state' },
                     {
-                        status: "CLOSED",
+                        status: 'CLOSED',
                         sessionInfo: {
-                            merge: [
-                                { var: "state.sessionInfo" },
-                                { adjournedAt: { var: "event.adjournedAt" } },
-                            ],
+                            merge: [{ var: 'state.sessionInfo' }, { adjournedAt: { var: 'event.adjournedAt' } }],
                         },
                     },
+                    {
+                        _emit: [{ name: 'MEETING_ADJOURNED', data: { var: 'event' }, destination: 'external' }],
+                    },
                 ],
             },
-            emits: ["MEETING_ADJOURNED"],
         },
     ],
 });