@emilia-protocol/gate 0.10.0 → 0.13.0

package/adapters/jira.js

@@ -1,56 +1,4 @@
 // SPDX-License-Identifier: Apache-2.0
-/**
- * EMILIA Gate — Jira System-of-Record adapter.
- * Guards bulk issue delete, project delete, and permission grants so they never
- * reach Jira without a receipt bound to THIS resource. Client injected.
- */
-import { createAdapter, manifestFromPack, hashCanonical } from './_kit.js';
-
-export const JIRA_ACTION_PACK = Object.freeze([
-  Object.freeze({
-    id: 'jira.issue.bulk_delete', label: 'Bulk delete issues', action_type: 'jira.issue.bulk_delete',
-    risk: 'critical', receipt_required: true, assurance_class: 'class_a',
-    match: { protocol: 'jira', tool: 'bulk_delete_issues' },
-    why: 'Mass-destroys issues. Bind the exact JQL.',
-    execution_binding: { required_fields: ['action_type', 'project', 'jql_hash'] },
-  }),
-  Object.freeze({
-    id: 'jira.project.delete', label: 'Delete project', action_type: 'jira.project.delete',
-    risk: 'critical', receipt_required: true, assurance_class: 'quorum',
-    match: { protocol: 'jira', tool: 'delete_project' },
-    why: 'Deletes a project and its issues. Quorum.',
-    execution_binding: { required_fields: ['action_type', 'project_key'] },
-  }),
-  Object.freeze({
-    id: 'jira.permission.grant', label: 'Grant permission', action_type: 'jira.permission.grant',
-    risk: 'critical', receipt_required: true, assurance_class: 'quorum',
-    match: { protocol: 'jira', tool: 'grant_permission' },
-    why: 'Changes who can act. Quorum + bind project/principal/role.',
-    execution_binding: { required_fields: ['action_type', 'project', 'principal', 'role'] },
-  }),
-]);
-
-const OPS = {
-  'issue.bulk_delete': {
-    selector: { protocol: 'jira', tool: 'bulk_delete_issues' },
-    observed: (p) => ({ action_type: 'jira.issue.bulk_delete', project: p.project, jql_hash: hashCanonical(String(p.jql || '').trim()) }),
-    actuator: (p, observed) => ({ ...observed, jql: p.jql }),
-    perform: (c, p) => c.bulkDeleteIssues({ project: p.project, jql: p.jql }),
-  },
-  'project.delete': {
-    selector: { protocol: 'jira', tool: 'delete_project' },
-    observed: (p) => ({ action_type: 'jira.project.delete', project_key: p.project_key }),
-    perform: (c, p) => c.deleteProject({ projectKey: p.project_key }),
-  },
-  'permission.grant': {
-    selector: { protocol: 'jira', tool: 'grant_permission' },
-    observed: (p) => ({ action_type: 'jira.permission.grant', project: p.project, principal: p.principal, role: p.role }),
-    perform: (c, p) => c.grantPermission({ project: p.project, principal: p.principal, role: p.role }),
-  },
-};
-
-const adapter = createAdapter({ system: 'jira', ops: OPS });
-export const JIRA_OPS = adapter.OPS;
-export function createJiraManifest(extra = []) { return manifestFromPack(JIRA_ACTION_PACK, extra); }
-export function guardJiraMutation(gate, client, args) { return adapter.guard(gate, client, args); }
-export default { JIRA_ACTION_PACK, JIRA_OPS, createJiraManifest, guardJiraMutation };
+// Compatibility entry point for the TypeScript jira adapter module.
+export * from '../dist/adapters/jira.js';
+export { default } from '../dist/adapters/jira.js';

package/adapters/k8s.js

@@ -1,71 +1,4 @@
 // SPDX-License-Identifier: Apache-2.0
-/**
- * EMILIA Gate — Kubernetes System-of-Record adapter.
- *
- * "Install this before your agent can touch the cluster." Guards the operations
- * that take a cluster down or hand it away — namespace delete, workload delete,
- * RBAC binding, secret delete — so they never reach the API server without a
- * receipt bound to THIS namespace/resource. Client is injected (a @kubernetes/
- * client-node wrapper or compatible).
- */
-import { createAdapter, manifestFromPack } from './_kit.js';
-
-export const K8S_ACTION_PACK = Object.freeze([
-  Object.freeze({
-    id: 'k8s.namespace.delete', label: 'Delete namespace', action_type: 'k8s.namespace.delete',
-    risk: 'critical', receipt_required: true, assurance_class: 'quorum',
-    match: { protocol: 'k8s', tool: 'delete_namespace' },
-    why: 'Deletes an entire namespace and everything in it. Quorum.',
-    execution_binding: { required_fields: ['action_type', 'namespace'] },
-  }),
-  Object.freeze({
-    id: 'k8s.workload.delete', label: 'Delete workload', action_type: 'k8s.workload.delete',
-    risk: 'high', receipt_required: true, assurance_class: 'class_a',
-    match: { protocol: 'k8s', tool: 'delete_workload' },
-    why: 'Deletes a deployment/statefulset/job. Bind namespace+kind+name.',
-    execution_binding: { required_fields: ['action_type', 'namespace', 'kind', 'name'] },
-  }),
-  Object.freeze({
-    id: 'k8s.rbac.bind', label: 'RBAC binding', action_type: 'k8s.rbac.bind',
-    risk: 'critical', receipt_required: true, assurance_class: 'quorum',
-    match: { protocol: 'k8s', tool: 'create_role_binding' },
-    why: 'Grants cluster permissions. Privilege change → two-person rule.',
-    execution_binding: { required_fields: ['action_type', 'subject', 'role', 'namespace'] },
-  }),
-  Object.freeze({
-    id: 'k8s.secret.delete', label: 'Delete secret', action_type: 'k8s.secret.delete',
-    risk: 'high', receipt_required: true, assurance_class: 'class_a',
-    match: { protocol: 'k8s', tool: 'delete_secret' },
-    why: 'Destroys a secret. Bind namespace+name.',
-    execution_binding: { required_fields: ['action_type', 'namespace', 'name'] },
-  }),
-]);
-
-const OPS = {
-  'namespace.delete': {
-    selector: { protocol: 'k8s', tool: 'delete_namespace' },
-    observed: (p) => ({ action_type: 'k8s.namespace.delete', namespace: p.namespace }),
-    perform: (c, p) => c.deleteNamespace({ namespace: p.namespace }),
-  },
-  'workload.delete': {
-    selector: { protocol: 'k8s', tool: 'delete_workload' },
-    observed: (p) => ({ action_type: 'k8s.workload.delete', namespace: p.namespace, kind: p.kind, name: p.name }),
-    perform: (c, p) => c.deleteWorkload({ namespace: p.namespace, kind: p.kind, name: p.name }),
-  },
-  'rbac.bind': {
-    selector: { protocol: 'k8s', tool: 'create_role_binding' },
-    observed: (p) => ({ action_type: 'k8s.rbac.bind', subject: p.subject, role: p.role, namespace: p.namespace }),
-    perform: (c, p) => c.createRoleBinding({ subject: p.subject, role: p.role, namespace: p.namespace }),
-  },
-  'secret.delete': {
-    selector: { protocol: 'k8s', tool: 'delete_secret' },
-    observed: (p) => ({ action_type: 'k8s.secret.delete', namespace: p.namespace, name: p.name }),
-    perform: (c, p) => c.deleteSecret({ namespace: p.namespace, name: p.name }),
-  },
-};
-
-const adapter = createAdapter({ system: 'k8s', ops: OPS });
-export const K8S_OPS = adapter.OPS;
-export function createK8sManifest(extraActions = []) { return manifestFromPack(K8S_ACTION_PACK, extraActions); }
-export function guardK8sMutation(gate, client, args) { return adapter.guard(gate, client, args); }
-export default { K8S_ACTION_PACK, K8S_OPS, createK8sManifest, guardK8sMutation };
+// Compatibility entry point for the TypeScript k8s adapter module.
+export * from '../dist/adapters/k8s.js';
+export { default } from '../dist/adapters/k8s.js';

package/adapters/linear.js

@@ -1,56 +1,4 @@
 // SPDX-License-Identifier: Apache-2.0
-/**
- * EMILIA Gate — Linear System-of-Record adapter.
- * Guards issue deletion, bulk delete, and team deletion so they never reach
- * Linear without a receipt bound to THIS resource. Client injected.
- */
-import { createAdapter, manifestFromPack, hashCanonical } from './_kit.js';
-
-export const LINEAR_ACTION_PACK = Object.freeze([
-  Object.freeze({
-    id: 'linear.issue.delete', label: 'Delete issue', action_type: 'linear.issue.delete',
-    risk: 'high', receipt_required: true, assurance_class: 'class_a',
-    match: { protocol: 'linear', tool: 'delete_issue' },
-    why: 'Destroys an issue. Bind the issue id.',
-    execution_binding: { required_fields: ['action_type', 'issue_id'] },
-  }),
-  Object.freeze({
-    id: 'linear.issue.bulk_delete', label: 'Bulk delete issues', action_type: 'linear.issue.bulk_delete',
-    risk: 'critical', receipt_required: true, assurance_class: 'class_a',
-    match: { protocol: 'linear', tool: 'bulk_delete_issues' },
-    why: 'Mass-destroys issues. Bind the exact query.',
-    execution_binding: { required_fields: ['action_type', 'team', 'query_hash'] },
-  }),
-  Object.freeze({
-    id: 'linear.team.delete', label: 'Delete team', action_type: 'linear.team.delete',
-    risk: 'critical', receipt_required: true, assurance_class: 'quorum',
-    match: { protocol: 'linear', tool: 'delete_team' },
-    why: 'Deletes a team and its issues. Quorum.',
-    execution_binding: { required_fields: ['action_type', 'team_id'] },
-  }),
-]);
-
-const OPS = {
-  'issue.delete': {
-    selector: { protocol: 'linear', tool: 'delete_issue' },
-    observed: (p) => ({ action_type: 'linear.issue.delete', issue_id: p.issue_id }),
-    perform: (c, p) => c.deleteIssue({ issueId: p.issue_id }),
-  },
-  'issue.bulk_delete': {
-    selector: { protocol: 'linear', tool: 'bulk_delete_issues' },
-    observed: (p) => ({ action_type: 'linear.issue.bulk_delete', team: p.team, query_hash: hashCanonical(String(p.query || '').trim()) }),
-    actuator: (p, observed) => ({ ...observed, query: p.query }),
-    perform: (c, p) => c.bulkDeleteIssues({ team: p.team, query: p.query }),
-  },
-  'team.delete': {
-    selector: { protocol: 'linear', tool: 'delete_team' },
-    observed: (p) => ({ action_type: 'linear.team.delete', team_id: p.team_id }),
-    perform: (c, p) => c.deleteTeam({ teamId: p.team_id }),
-  },
-};
-
-const adapter = createAdapter({ system: 'linear', ops: OPS });
-export const LINEAR_OPS = adapter.OPS;
-export function createLinearManifest(extra = []) { return manifestFromPack(LINEAR_ACTION_PACK, extra); }
-export function guardLinearMutation(gate, client, args) { return adapter.guard(gate, client, args); }
-export default { LINEAR_ACTION_PACK, LINEAR_OPS, createLinearManifest, guardLinearMutation };
+// Compatibility entry point for the TypeScript linear adapter module.
+export * from '../dist/adapters/linear.js';
+export { default } from '../dist/adapters/linear.js';

package/adapters/salesforce.js

@@ -1,56 +1,4 @@
 // SPDX-License-Identifier: Apache-2.0
-/**
- * EMILIA Gate — Salesforce System-of-Record adapter.
- * Guards bulk record delete, data export, and permission-set assignment so they
- * never reach Salesforce without a receipt bound to THIS object. Client injected.
- */
-import { createAdapter, manifestFromPack, hashCanonical } from './_kit.js';
-
-export const SALESFORCE_ACTION_PACK = Object.freeze([
-  Object.freeze({
-    id: 'salesforce.records.bulk_delete', label: 'Bulk delete records', action_type: 'salesforce.records.bulk_delete',
-    risk: 'critical', receipt_required: true, assurance_class: 'class_a',
-    match: { protocol: 'salesforce', tool: 'bulk_delete' },
-    why: 'Mass-destroys CRM records. Bind object + the exact SOQL.',
-    execution_binding: { required_fields: ['action_type', 'object', 'soql_hash'] },
-  }),
-  Object.freeze({
-    id: 'salesforce.data.export', label: 'Bulk data export', action_type: 'salesforce.data.export',
-    risk: 'high', receipt_required: true, assurance_class: 'class_a',
-    match: { protocol: 'salesforce', tool: 'export' },
-    why: 'Exfiltrates CRM data. Bind object + recipient.',
-    execution_binding: { required_fields: ['action_type', 'object', 'recipient'] },
-  }),
-  Object.freeze({
-    id: 'salesforce.permission_set.assign', label: 'Assign permission set', action_type: 'salesforce.permission_set.assign',
-    risk: 'critical', receipt_required: true, assurance_class: 'quorum',
-    match: { protocol: 'salesforce', tool: 'assign_permission_set' },
-    why: 'Grants privileges. Quorum + bind user + permission set.',
-    execution_binding: { required_fields: ['action_type', 'user', 'permission_set'] },
-  }),
-]);
-
-const OPS = {
-  'records.bulk_delete': {
-    selector: { protocol: 'salesforce', tool: 'bulk_delete' },
-    observed: (p) => ({ action_type: 'salesforce.records.bulk_delete', object: p.object, soql_hash: hashCanonical(String(p.soql || '').trim()) }),
-    actuator: (p, observed) => ({ ...observed, soql: p.soql }),
-    perform: (c, p) => c.bulkDelete({ object: p.object, soql: p.soql }),
-  },
-  'data.export': {
-    selector: { protocol: 'salesforce', tool: 'export' },
-    observed: (p) => ({ action_type: 'salesforce.data.export', object: p.object, recipient: p.recipient }),
-    perform: (c, p) => c.export({ object: p.object, recipient: p.recipient }),
-  },
-  'permission_set.assign': {
-    selector: { protocol: 'salesforce', tool: 'assign_permission_set' },
-    observed: (p) => ({ action_type: 'salesforce.permission_set.assign', user: p.user, permission_set: p.permission_set }),
-    perform: (c, p) => c.assignPermissionSet({ user: p.user, permissionSet: p.permission_set }),
-  },
-};
-
-const adapter = createAdapter({ system: 'salesforce', ops: OPS });
-export const SALESFORCE_OPS = adapter.OPS;
-export function createSalesforceManifest(extra = []) { return manifestFromPack(SALESFORCE_ACTION_PACK, extra); }
-export function guardSalesforceMutation(gate, client, args) { return adapter.guard(gate, client, args); }
-export default { SALESFORCE_ACTION_PACK, SALESFORCE_OPS, createSalesforceManifest, guardSalesforceMutation };
+// Compatibility entry point for the TypeScript salesforce adapter module.
+export * from '../dist/adapters/salesforce.js';
+export { default } from '../dist/adapters/salesforce.js';

package/adapters/stripe.js

@@ -1,82 +1,4 @@
 // SPDX-License-Identifier: Apache-2.0
-/**
- * EMILIA Gate — Stripe / payments System-of-Record adapter.
- *
- * "Install this before your agent can move money." Wraps the destructive Stripe
- * operations so a payout, refund, or payout-destination change never reaches
- * Stripe without a valid, sufficiently-assured, non-replayed receipt bound to
- * THIS amount/destination. A receipt for $100 to acct_A cannot authorize
- * $10,000 to acct_B.
- *
- *   import Stripe from 'stripe';
- *   import { createGate } from '@emilia-protocol/gate';
- *   import { createStripeManifest, guardStripeMutation } from '@emilia-protocol/gate/adapters/stripe';
- *
- *   const gate = createGate({ manifest: createStripeManifest(), trustedKeys: [ISSUER], store: sharedConsumptionStore });
- *   await guardStripeMutation(gate, new Stripe(key), {
- *     op: 'payout.create', params: { amount: 40000, currency: 'usd', destination: 'acct_x' }, receipt,
- *   });
- */
-import { createAdapter, manifestFromPack } from './_kit.js';
-
-export const STRIPE_ACTION_PACK = Object.freeze([
-  Object.freeze({
-    id: 'stripe.payout.create', label: 'Stripe payout', action_type: 'stripe.payout.create',
-    risk: 'critical', receipt_required: true, assurance_class: 'class_a',
-    match: { protocol: 'stripe', tool: 'create_payout' },
-    why: 'Moves money out. Bind amount/currency/destination to a named human approval.',
-    execution_binding: { required_fields: ['action_type', 'amount', 'currency', 'destination'] },
-  }),
-  Object.freeze({
-    id: 'stripe.refund.create', label: 'Stripe refund', action_type: 'stripe.refund.create',
-    risk: 'high', receipt_required: true, assurance_class: 'class_a',
-    match: { protocol: 'stripe', tool: 'create_refund' },
-    why: 'Returns funds. Bind the payment and amount so a refund cannot be silently inflated.',
-    execution_binding: { required_fields: ['action_type', 'payment_intent', 'amount'] },
-  }),
-  Object.freeze({
-    id: 'stripe.bank_account.change', label: 'Stripe payout-destination change', action_type: 'stripe.bank_account.change',
-    risk: 'critical', receipt_required: true, assurance_class: 'quorum',
-    match: { protocol: 'stripe', tool: 'update_external_account' },
-    why: 'Changes WHERE future money flows. Quorum: the classic redirect-the-payouts attack.',
-    execution_binding: { required_fields: ['action_type', 'account', 'external_account'] },
-  }),
-]);
-
-const OPS = {
-  'payout.create': {
-    selector: { protocol: 'stripe', tool: 'create_payout' },
-    observed: (p) => ({ action_type: 'stripe.payout.create', amount: p.amount, currency: p.currency, destination: p.destination }),
-    perform: (stripe, p) => stripe.payouts.create({ amount: p.amount, currency: p.currency, destination: p.destination }),
-  },
-  'refund.create': {
-    selector: { protocol: 'stripe', tool: 'create_refund' },
-    observed: (p) => ({ action_type: 'stripe.refund.create', payment_intent: p.payment_intent, amount: p.amount }),
-    perform: (stripe, p) => stripe.refunds.create({ payment_intent: p.payment_intent, amount: p.amount }),
-  },
-  'bank_account.change': {
-    selector: { protocol: 'stripe', tool: 'update_external_account' },
-    observed: (p) => ({ action_type: 'stripe.bank_account.change', account: p.account, external_account: p.external_account }),
-    perform: (stripe, p) => stripe.accounts.updateExternalAccount(p.account, p.external_account, p.update || {}),
-  },
-};
-
-const adapter = createAdapter({ system: 'stripe', ops: OPS });
-export const STRIPE_OPS = adapter.OPS;
-
-export function createStripeManifest(extraActions = []) {
-  return manifestFromPack(STRIPE_ACTION_PACK, extraActions);
-}
-
-/**
- * Guard a destructive Stripe mutation behind the gate.
- * @param {object} gate    a gate built with createStripeManifest()
- * @param {object} stripe  a Stripe-like client (the official `stripe` SDK or compatible)
- * @param {object} o       { op:'payout.create'|'refund.create'|'bank_account.change', params, receipt }
- * @throws Error{code:'EMILIA_RECEIPT_REQUIRED'} if refused — the call never reaches Stripe
- */
-export function guardStripeMutation(gate, stripe, args) {
-  return adapter.guard(gate, stripe, args);
-}
-
-export default { STRIPE_ACTION_PACK, STRIPE_OPS, createStripeManifest, guardStripeMutation };
+// Compatibility entry point for the TypeScript stripe adapter module.
+export * from '../dist/adapters/stripe.js';
+export { default } from '../dist/adapters/stripe.js';

package/adapters/supabase.js

@@ -1,122 +1,4 @@
 // SPDX-License-Identifier: Apache-2.0
-/**
- * EMILIA Gate — Supabase / Postgres System-of-Record adapter.
- *
- * "Install this before your agent can run destructive SQL." Wraps the dangerous
- * database operations — destructive SQL (DELETE/DROP/TRUNCATE/UPDATE), bulk
- * export, and RLS-policy change — so they never execute without a valid,
- * sufficiently-assured, non-replayed receipt bound to THIS statement/table. The
- * exact statement is bound by hash, so an approval for one DELETE cannot be
- * swapped for a DROP.
- *
- *   import { createGate } from '@emilia-protocol/gate';
- *   import { createSupabaseManifest, guardSupabaseMutation, isDestructiveSql } from '@emilia-protocol/gate/adapters/supabase';
- *
- *   const gate = createGate({ manifest: createSupabaseManifest(), trustedKeys: [ISSUER], store: sharedConsumptionStore });
- *   // client: anything with .query(sql) (node-postgres / a Supabase RPC wrapper).
- *   await guardSupabaseMutation(gate, client, {
- *     op: 'sql.destructive', params: { sql: 'DELETE FROM payments WHERE id=1', table: 'payments' }, receipt,
- *   });
- */
-import { createAdapter, manifestFromPack, hashCanonical } from './_kit.js';
-
-export const RLS_DEFINITION_BINDING_VERSION = 'EP-SUPABASE-RLS-DEFINITION-v1';
-
-const DESTRUCTIVE = /\b(delete|drop|truncate|alter\s+table)\b/i;
-const UPDATE_NO_WHERE = /\bupdate\b(?:(?!\bwhere\b).)*$/is;
-
-/** Heuristic: is this SQL destructive (DELETE/DROP/TRUNCATE/ALTER, or UPDATE without WHERE)? */
-export function isDestructiveSql(sql) {
-  const s = String(sql || '');
-  return DESTRUCTIVE.test(s) || UPDATE_NO_WHERE.test(s.trim());
-}
-
-/** Canonical hash of a SQL statement, whitespace-collapsed and lowercased. */
-export function statementHash(sql) {
-  return hashCanonical(String(sql || '').replace(/\s+/g, ' ').trim().toLowerCase());
-}
-
-/** Digest the exact canonical RLS definition without placing it in evidence. */
-export function rlsDefinitionDigest(definition) {
-  return hashCanonical({
-    version: RLS_DEFINITION_BINDING_VERSION,
-    definition,
-  });
-}
-
-export const SUPABASE_ACTION_PACK = Object.freeze([
-  Object.freeze({
-    id: 'supabase.sql.destructive', label: 'Destructive SQL', action_type: 'supabase.sql.destructive',
-    risk: 'critical', receipt_required: true, assurance_class: 'class_a',
-    match: { protocol: 'supabase', tool: 'execute_sql' },
-    why: 'DELETE/DROP/TRUNCATE/ALTER destroys or rewrites system-of-record state. Bind the exact statement.',
-    execution_binding: { required_fields: ['action_type', 'statement_hash'] },
-  }),
-  Object.freeze({
-    id: 'supabase.data.export', label: 'Bulk data export', action_type: 'supabase.data.export',
-    risk: 'high', receipt_required: true, assurance_class: 'class_a',
-    match: { protocol: 'supabase', tool: 'export_table' },
-    why: 'Moves data out of its system of record. Bind table + recipient to the approval.',
-    execution_binding: { required_fields: ['action_type', 'table', 'recipient'] },
-  }),
-  Object.freeze({
-    id: 'supabase.rls.change', label: 'RLS policy change', action_type: 'supabase.rls.change',
-    risk: 'critical', receipt_required: true, assurance_class: 'quorum',
-    match: { protocol: 'supabase', tool: 'alter_policy' },
-    why: 'Changes who can read/write rows. Row-Level-Security changes deserve the two-person rule.',
-    execution_binding: {
-      required_fields: [
-        'action_type', 'table', 'policy', 'rls_definition_digest', 'rls_definition_version',
-      ],
-    },
-  }),
-]);
-
-const OPS = {
-  'sql.destructive': {
-    selector: { protocol: 'supabase', tool: 'execute_sql' },
-    observed: (p) => ({ action_type: 'supabase.sql.destructive', statement_hash: statementHash(p.sql) }),
-    actuator: (p, observed) => ({ ...observed, sql: p.sql }),
-    perform: (client, p) => client.query(p.sql),
-  },
-  'data.export': {
-    selector: { protocol: 'supabase', tool: 'export_table' },
-    observed: (p) => ({ action_type: 'supabase.data.export', table: p.table, recipient: p.recipient }),
-    perform: (client, p) => client.export(p.table, p.recipient),
-  },
-  'rls.change': {
-    selector: { protocol: 'supabase', tool: 'alter_policy' },
-    observed: (p) => ({
-      action_type: 'supabase.rls.change',
-      table: p.table,
-      policy: p.policy,
-      rls_definition_digest: rlsDefinitionDigest(p.definition),
-      rls_definition_version: RLS_DEFINITION_BINDING_VERSION,
-    }),
-    actuator: (p, observed) => ({ ...observed, definition: p.definition }),
-    perform: (client, p) => client.alterPolicy(p.table, p.policy, p.definition),
-  },
-};
-
-const adapter = createAdapter({ system: 'supabase', ops: OPS });
-export const SUPABASE_OPS = adapter.OPS;
-
-export function createSupabaseManifest(extraActions = []) {
-  return manifestFromPack(SUPABASE_ACTION_PACK, extraActions);
-}
-
-/**
- * Guard a destructive Supabase/Postgres mutation behind the gate.
- * @param {object} gate    a gate built with createSupabaseManifest()
- * @param {object} client  a client exposing { query(sql), export(table,recipient), alterPolicy(table,policy,def) }
- * @param {object} o       { op:'sql.destructive'|'data.export'|'rls.change', params, receipt }
- * @throws Error{code:'EMILIA_RECEIPT_REQUIRED'} if refused — the statement never executes
- */
-export function guardSupabaseMutation(gate, client, args) {
-  return adapter.guard(gate, client, args);
-}
-
-export default {
-  SUPABASE_ACTION_PACK, SUPABASE_OPS, createSupabaseManifest, guardSupabaseMutation,
-  isDestructiveSql, statementHash, rlsDefinitionDigest, RLS_DEFINITION_BINDING_VERSION,
-};
+// Compatibility entry point for the TypeScript supabase adapter module.
+export * from '../dist/adapters/supabase.js';
+export { default } from '../dist/adapters/supabase.js';

package/adapters/terraform.js

@@ -1,60 +1,4 @@
 // SPDX-License-Identifier: Apache-2.0
-/**
- * EMILIA Gate — Terraform System-of-Record adapter.
- *
- * "Install this before your agent can destroy infrastructure." Guards the
- * irreversible Terraform operations — destroy, state rm, workspace delete — so
- * they never run without a receipt bound to THIS workspace/plan. The destroy
- * plan is bound by hash, so an approved small destroy cannot be swapped for a
- * full teardown. Runner is injected (a `terraform`/`tofu` CLI wrapper or Cloud
- * API client).
- */
-import { createAdapter, manifestFromPack } from './_kit.js';
-
-export const TERRAFORM_ACTION_PACK = Object.freeze([
-  Object.freeze({
-    id: 'terraform.apply.destroy', label: 'Terraform destroy', action_type: 'terraform.apply.destroy',
-    risk: 'critical', receipt_required: true, assurance_class: 'quorum',
-    match: { protocol: 'terraform', tool: 'destroy' },
-    why: 'Tears down real infrastructure. Bind the workspace + plan hash; quorum.',
-    execution_binding: { required_fields: ['action_type', 'workspace', 'plan_hash'] },
-  }),
-  Object.freeze({
-    id: 'terraform.state.rm', label: 'Terraform state rm', action_type: 'terraform.state.rm',
-    risk: 'high', receipt_required: true, assurance_class: 'class_a',
-    match: { protocol: 'terraform', tool: 'state_rm' },
-    why: 'Detaches a resource from state (orphans real infra). Bind workspace+address.',
-    execution_binding: { required_fields: ['action_type', 'workspace', 'address'] },
-  }),
-  Object.freeze({
-    id: 'terraform.workspace.delete', label: 'Terraform workspace delete', action_type: 'terraform.workspace.delete',
-    risk: 'high', receipt_required: true, assurance_class: 'class_a',
-    match: { protocol: 'terraform', tool: 'workspace_delete' },
-    why: 'Deletes a workspace and its state. Bind the workspace.',
-    execution_binding: { required_fields: ['action_type', 'workspace'] },
-  }),
-]);
-
-const OPS = {
-  'apply.destroy': {
-    selector: { protocol: 'terraform', tool: 'destroy' },
-    observed: (p) => ({ action_type: 'terraform.apply.destroy', workspace: p.workspace, plan_hash: p.plan_hash }),
-    perform: (r, p) => r.destroy({ workspace: p.workspace, plan_hash: p.plan_hash }),
-  },
-  'state.rm': {
-    selector: { protocol: 'terraform', tool: 'state_rm' },
-    observed: (p) => ({ action_type: 'terraform.state.rm', workspace: p.workspace, address: p.address }),
-    perform: (r, p) => r.stateRm({ workspace: p.workspace, address: p.address }),
-  },
-  'workspace.delete': {
-    selector: { protocol: 'terraform', tool: 'workspace_delete' },
-    observed: (p) => ({ action_type: 'terraform.workspace.delete', workspace: p.workspace }),
-    perform: (r, p) => r.workspaceDelete({ workspace: p.workspace }),
-  },
-};
-
-const adapter = createAdapter({ system: 'terraform', ops: OPS });
-export const TERRAFORM_OPS = adapter.OPS;
-export function createTerraformManifest(extraActions = []) { return manifestFromPack(TERRAFORM_ACTION_PACK, extraActions); }
-export function guardTerraformMutation(gate, runner, args) { return adapter.guard(gate, runner, args); }
-export default { TERRAFORM_ACTION_PACK, TERRAFORM_OPS, createTerraformManifest, guardTerraformMutation };
+// Compatibility entry point for the TypeScript terraform adapter module.
+export * from '../dist/adapters/terraform.js';
+export { default } from '../dist/adapters/terraform.js';

package/adapters/vercel.js

@@ -1,85 +1,4 @@
 // SPDX-License-Identifier: Apache-2.0
-/**
- * EMILIA Gate — Vercel System-of-Record adapter.
- * Guards promote-to-production, project delete, and env/secret changes so they
- * never reach Vercel without a receipt bound to THIS project. Client injected
- * (the Vercel REST client or a thin wrapper).
- */
-import { createAdapter, manifestFromPack, hashCanonical } from './_kit.js';
-
-export const SECRET_VALUE_BINDING_VERSION = 'EP-VERCEL-SECRET-VALUE-v1';
-
-/** Digest an exact secret value for receipt binding; callers must never log it. */
-export function secretValueDigest(value) {
-  return hashCanonical({
-    version: SECRET_VALUE_BINDING_VERSION,
-    value,
-  });
-}
-
-export const VERCEL_ACTION_PACK = Object.freeze([
-  Object.freeze({
-    id: 'vercel.deploy.promote', label: 'Promote to production', action_type: 'vercel.deploy.promote',
-    risk: 'critical', receipt_required: true, assurance_class: 'quorum',
-    match: { protocol: 'vercel', tool: 'promote_deployment' },
-    why: 'Changes live production. Quorum for the prod cutover.',
-    execution_binding: { required_fields: ['action_type', 'project', 'deployment_id'] },
-  }),
-  Object.freeze({
-    id: 'vercel.project.delete', label: 'Delete project', action_type: 'vercel.project.delete',
-    risk: 'critical', receipt_required: true, assurance_class: 'class_a',
-    match: { protocol: 'vercel', tool: 'delete_project' },
-    why: 'Destroys a project and its deployments. Bind the project.',
-    execution_binding: { required_fields: ['action_type', 'project'] },
-  }),
-  Object.freeze({
-    id: 'vercel.env.set', label: 'Set env / secret', action_type: 'vercel.env.set',
-    risk: 'high', receipt_required: true, assurance_class: 'class_a',
-    match: { protocol: 'vercel', tool: 'upsert_env' },
-    why: 'Changes production secrets/config. Bind project+key+target.',
-    execution_binding: {
-      required_fields: [
-        'action_type', 'project', 'key', 'target', 'secret_value_digest', 'secret_value_version',
-      ],
-    },
-  }),
-]);
-
-const OPS = {
-  'deploy.promote': {
-    selector: { protocol: 'vercel', tool: 'promote_deployment' },
-    observed: (p) => ({ action_type: 'vercel.deploy.promote', project: p.project, deployment_id: p.deployment_id }),
-    perform: (c, p) => c.promoteDeployment({ project: p.project, deploymentId: p.deployment_id }),
-  },
-  'project.delete': {
-    selector: { protocol: 'vercel', tool: 'delete_project' },
-    observed: (p) => ({ action_type: 'vercel.project.delete', project: p.project }),
-    perform: (c, p) => c.deleteProject({ project: p.project }),
-  },
-  'env.set': {
-    selector: { protocol: 'vercel', tool: 'upsert_env' },
-    observed: (p) => ({
-      action_type: 'vercel.env.set',
-      project: p.project,
-      key: p.key,
-      target: p.target,
-      secret_value_digest: secretValueDigest(p.value),
-      secret_value_version: SECRET_VALUE_BINDING_VERSION,
-    }),
-    actuator: (p, observed) => ({ ...observed, value: p.value }),
-    perform: (c, p) => c.upsertEnv({ project: p.project, key: p.key, value: p.value, target: p.target }),
-  },
-};
-
-const adapter = createAdapter({ system: 'vercel', ops: OPS });
-export const VERCEL_OPS = adapter.OPS;
-export function createVercelManifest(extra = []) { return manifestFromPack(VERCEL_ACTION_PACK, extra); }
-export function guardVercelMutation(gate, client, args) { return adapter.guard(gate, client, args); }
-export default {
-  VERCEL_ACTION_PACK,
-  VERCEL_OPS,
-  SECRET_VALUE_BINDING_VERSION,
-  secretValueDigest,
-  createVercelManifest,
-  guardVercelMutation,
-};
+// Compatibility entry point for the TypeScript vercel adapter module.
+export * from '../dist/adapters/vercel.js';
+export { default } from '../dist/adapters/vercel.js';