@geonosis/policy 1.0.0

package/dist/medusa/index.d.ts

@@ -0,0 +1,81 @@
+import { PermissionAction } from '../permissions/index.js';
+import { A as Awaitable, P as PolicyQuery, d as PolicyRule, p as PolicyJournalEntry, a as PolicyRuleRow, b as PolicyAdapter } from '../types-DzC5zTZ8.js';
+
+/**
+ * The Medusa store, behind the ports the kernel reads.
+ *
+ * Nothing here imports `@medusajs/*`. The container is a thing the runtime hands the caller, so it
+ * arrives as an argument — which is also what makes every check in the conformance suite runnable
+ * without a booted server, and what let the 219 lines of resolution logic this package extracted
+ * stop dragging a module, a service and three ORM models behind them.
+ */
+/** The bit of the container this needs — structural, so a plain object stands in for it. */
+type MedusaContainerLike = {
+    resolve: (key: string) => unknown;
+};
+/** The bit of the module service this needs: the generated list, and the generated create. */
+type MedusaPolicyServiceLike = {
+    createPolicyJournalEntries?: (data: Record<string, unknown>) => Awaitable<unknown>;
+    listPolicyRules?: (filter: Record<string, unknown>) => Awaitable<readonly PolicyRuleRow[]>;
+};
+/** The bit of a runtime-config service this needs. Its `get` answers with the fallback it is given. */
+type ConfigStoreLike = {
+    get: <T>(namespace: string, key: string, fallback: T) => Awaitable<T>;
+};
+type ConfigStoreBinding = (store: ConfigStoreLike, query: PolicyQuery) => Awaitable<unknown>;
+/**
+ * One row of the runtime config, as the value of one kind.
+ *
+ * The fallback handed to `get` is `undefined` on purpose: the service answers with whatever it is
+ * given when no row exists, so the only way to tell an unset row from a row holding that same value
+ * is to hand it something no row can legitimately hold. Junk in the row is not filtered here — the
+ * KIND's schema refuses it, once, for every layer that could produce one.
+ */
+declare const configRow: (namespace: string, key: string) => ConfigStoreBinding;
+type MedusaPolicyAdapterOptions = {
+    /** Which config rows stand for which kind. A kind with no binding has no admin-set value. */
+    bindings?: Record<string, ConfigStoreBinding>;
+    configStoreKey?: string;
+    container: MedusaContainerLike;
+    /** What that store calls its own events, e.g. `rules_engine.`. */
+    eventPrefix?: string;
+    /** Rules from somewhere other than the table — a learned playbook's, appended LAST. */
+    extraRules?: () => Awaitable<readonly PolicyRule[]>;
+    moduleKey: string;
+    /** The row this store keeps. Overridden when its columns are not these. */
+    toRow?: (entry: PolicyJournalEntry, eventPrefix: string) => Record<string, unknown>;
+};
+declare const createMedusaPolicyAdapter: (options: MedusaPolicyAdapterOptions) => PolicyAdapter;
+/** One role as that module holds it: an id, and the policies granted to it. */
+type MedusaRbacRole = {
+    id: string;
+    policies?: readonly PermissionAction[];
+};
+/**
+ * The native RBAC module's roles, as grants the permission lattice can read.
+ *
+ * This is the whole bridge. Upstream's `hasPermission` fetches these itself through the container
+ * and a cache, which is why nothing that uses it can be answered without a booted server; the fetch
+ * is the caller's here, and the decision is a value.
+ */
+declare const medusaGrants: (roles: readonly MedusaRbacRole[]) => Record<string, readonly PermissionAction[]>;
+/**
+ * The signature a middleware advertises, deliberately NOT the framework's `MiddlewareFunction`.
+ *
+ * That type carries `#private` class fields, so two copies of `@medusajs/framework` in one store
+ * make the same shape nominally incompatible and every `defineMiddlewares` call site goes red.
+ * `unknown` params are contravariant-safe: this assigns to every version's, and the runtime value
+ * is unchanged.
+ */
+type PortableMiddleware = (request: unknown, response: unknown, next: (error?: unknown) => void) => unknown;
+type Wrapper = (handler: PortableMiddleware, policies: PermissionAction[]) => PortableMiddleware;
+/**
+ * The framework's own permission check as a one-liner a route array can hold.
+ *
+ * The wrapper is passed in rather than imported, for the same reason the container is: a package
+ * that imported it would be unusable anywhere else, and would pin one of the two framework copies.
+ * The wrapped handler does nothing but continue — the wrapper itself is the gate.
+ */
+declare const requirePermission: (wrap: Wrapper, ...policies: PermissionAction[]) => PortableMiddleware;
+
+export { type ConfigStoreBinding, type ConfigStoreLike, type MedusaContainerLike, type MedusaPolicyAdapterOptions, type MedusaPolicyServiceLike, type MedusaRbacRole, type PortableMiddleware, configRow, createMedusaPolicyAdapter, medusaGrants, requirePermission };

package/dist/medusa/index.js

@@ -0,0 +1,59 @@
+import {
+  toPolicyRules
+} from "../chunk-JICJ4XEX.js";
+
+// src/medusa/index.ts
+var configRow = (namespace, key) => (store) => store.get(namespace, key, void 0);
+var defaultRow = (entry, eventPrefix) => ({
+  actor_kind: "system",
+  ...entry.rejected ? { error: `rejected ${JSON.stringify(entry.rejected.value)}: ${entry.rejected.reason}` } : {},
+  event_name: `${eventPrefix}${entry.event}`,
+  fell_back_to: { constraintKind: entry.kind, value: entry.fellBackTo },
+  ...entry.op ? { op: entry.op } : {},
+  ...entry.subject ? { subject: entry.subject } : {}
+});
+var attempt = async (what) => {
+  try {
+    return await what();
+  } catch {
+    return void 0;
+  }
+};
+var createMedusaPolicyAdapter = (options) => {
+  const bindings = options.bindings ?? {};
+  const eventPrefix = options.eventPrefix ?? "";
+  const toRow = options.toRow ?? defaultRow;
+  const service = () => options.container.resolve(options.moduleKey);
+  const store = () => options.container.resolve(options.configStoreKey ?? "configStore");
+  return {
+    config: {
+      get: async (kind, query) => {
+        const binding = bindings[kind];
+        return binding ? attempt(() => binding(store(), query)) : void 0;
+      }
+    },
+    journal: {
+      write: async (entry) => {
+        await attempt(() => service().createPolicyJournalEntries?.(toRow(entry, eventPrefix)));
+      }
+    },
+    name: `medusa:${options.moduleKey}`,
+    rule: {
+      rules: async () => [
+        ...toPolicyRules(await service().listPolicyRules?.({ status: "active" }) ?? []),
+        // Appended, never prepended: the lattice decides authority, and a list order that could
+        // stand in for it would be a second, silent one.
+        ...await options.extraRules?.() ?? []
+      ]
+    }
+  };
+};
+var medusaGrants = (roles) => Object.fromEntries(roles.map((role) => [role.id, role.policies ?? []]));
+var passThrough = (_request, _response, next) => next();
+var requirePermission = (wrap, ...policies) => wrap(passThrough, policies);
+export {
+  configRow,
+  createMedusaPolicyAdapter,
+  medusaGrants,
+  requirePermission
+};

package/dist/permissions/index.d.ts

@@ -0,0 +1,126 @@
+/**
+ * A permission lattice — Medusa 2.19.0's `definePolicies` / `hasPermission` / `resolvePermissions`
+ * with the container lifted out.
+ *
+ * dielime did not reinvent permissions and was right not to: it adopted the native module and put a
+ * typed registry in front of it. What that registry could not be given was a way to ANSWER the
+ * question without a booted container — so the same 22 named policies are unit-testable in node and
+ * the check they feed is not. Everything here is pure: the grants are data the caller fetched, and
+ * the answer is a value.
+ *
+ * Every semantic is pinned from the shipped implementation. No test file ships in either tarball.
+ */
+/** The single character used as the wildcard in BOTH the resource and the operation slot. */
+declare const WILDCARD = "*";
+type PolicyDefinition = {
+    description?: string;
+    name: string;
+    operation: string;
+    resource: string;
+};
+/** A resource with one or more operations on it — what a route asks for. */
+type PermissionAction = {
+    operation: readonly string[] | string;
+    resource: string;
+};
+/** A single (resource, operation) pair with the key a store would hold it under. */
+type ExpandedPolicy = {
+    key: string;
+    operation: string;
+    resource: string;
+};
+/** What each role has been granted. The caller fetched it; this decides with it. */
+type PolicyGrants = ReadonlyMap<string, readonly PermissionAction[]> | Readonly<Record<string, readonly PermissionAction[]>>;
+declare const permissionKey: (resource: string, operation: string) => string;
+/**
+ * `ReadBrands` → `read_brands`, and the wildcard through untouched.
+ *
+ * Exported because a repo has to be able to check its own vocabulary against it: an operation
+ * spelled `certificate:create` normalises to `certificate_create`, so a repo that authors its rows
+ * directly (as dielime does) and ALSO declares them through here would end up with two spellings of
+ * one permission and no error anywhere.
+ */
+declare const normalizePolicyKey: (key: string) => string;
+type DefinePoliciesOptions = {
+    normalize?: (key: string) => string;
+};
+/**
+ * Declare policies. Answers with them; registers nothing globally.
+ *
+ * Upstream writes into three `globalThis` registries and REWRITES the caller's objects in place, so
+ * the array you passed comes back normalised under you and a second file declaring the same name
+ * silently replaces the first. Neither is load-bearing for the decision, and both are surprising, so
+ * neither is reproduced — `createPolicyCatalog` is the registry, and it refuses a duplicate.
+ */
+declare const definePolicies: (policies: PolicyDefinition | readonly PolicyDefinition[], options?: DefinePoliciesOptions) => {
+    policies: PolicyDefinition[];
+};
+type PolicyCatalog = {
+    declare: (policies: PolicyDefinition | readonly PolicyDefinition[]) => PolicyDefinition[];
+    get: (name: string) => PolicyDefinition | undefined;
+    list: () => PolicyDefinition[];
+    operations: () => string[];
+    resources: () => string[];
+};
+/** The registry upstream keeps globally, made local and made to refuse a name already taken. */
+declare const createPolicyCatalog: (options?: DefinePoliciesOptions) => PolicyCatalog;
+/**
+ * Expand actions into the unique one-operation rows a store keeps, deduped, key derived.
+ *
+ * The key is `<resource>:<operation>` on the RAW operation, which is how a wildcard grant becomes
+ * the single `*:*` row that authorises every route — granting the union of a repo's own named
+ * policies instead covers its custom resources only, and 403s every native one.
+ */
+declare const expandPolicies: (actions: readonly PermissionAction[]) => ExpandedPolicy[];
+type HasPermissionInput = {
+    actions: PermissionAction | readonly PermissionAction[];
+    /**
+     * Whether the mechanism is on at all. `false` allows everything, which is what the `rbac` feature
+     * flag does upstream — and it is off by default there.
+     */
+    enabled?: boolean;
+    grants: PolicyGrants;
+    /**
+     * What an actor with NO roles gets. Upstream's `hasPermission` allows (`!roleIds?.length` returns
+     * true) while its own route wrapper denies, so the same request gets opposite answers depending
+     * on which door it came through. `allow` is upstream's answer here.
+     */
+    onEmptyRoles?: 'allow' | 'deny';
+    roles: readonly string[] | string;
+};
+/** Do these roles grant every one of these actions? */
+declare const hasPermission: (input: HasPermissionInput) => boolean;
+type ResolvePermissionsInput = {
+    enabled?: boolean;
+    grants: PolicyGrants;
+    roles: readonly string[] | string;
+    /** The (resource, operation) pairs to evaluate against, with wildcards expanded into them. */
+    universe: readonly {
+        operation: string;
+        resource: string;
+    }[];
+};
+/**
+ * The subset of the universe these roles are granted, keyed `resource:operation`.
+ *
+ * The inverse of `hasPermission`, for a client that would otherwise have to re-implement wildcard
+ * semantics to render a menu. Note the asymmetry, which is upstream's: with the mechanism off this
+ * answers with EVERYTHING, and for an actor with no roles it answers with NOTHING — where
+ * `hasPermission` answers true for that same actor.
+ */
+declare const resolvePermissions: (input: ResolvePermissionsInput) => Set<string>;
+type PermissionCheck = {
+    allowed: boolean;
+    required: string[];
+};
+/**
+ * The decision a route guard needs: the answer, plus WHICH permissions were required.
+ *
+ * A refusal that names them teaches the person blocked by it something; one that says "Forbidden"
+ * sends them to whoever owns the roles table. Denies a role-less actor, as the route wrapper does —
+ * but unlike the wrapper it still honours the flag, which the wrapper reads only after it has
+ * already thrown.
+ */
+declare const checkPermissions: (input: Omit<HasPermissionInput, "onEmptyRoles">) => PermissionCheck;
+
+export { type DefinePoliciesOptions, type ExpandedPolicy, type HasPermissionInput, type PermissionAction, type PermissionCheck, type PolicyCatalog, type PolicyDefinition, type PolicyGrants, type ResolvePermissionsInput, WILDCARD, checkPermissions, createPolicyCatalog, definePolicies, expandPolicies, hasPermission, normalizePolicyKey, permissionKey, resolvePermissions };

package/dist/permissions/index.js

@@ -0,0 +1,103 @@
+// src/permissions/index.ts
+var WILDCARD = "*";
+var permissionKey = (resource, operation) => `${resource}:${operation}`;
+var normalizePolicyKey = (key) => key === WILDCARD ? WILDCARD : key.replace(/([a-z])([A-Z])/g, "$1_$2").replace(/[^a-zA-Z0-9]+/g, "_").replace(/^_+|_+$/g, "").toLowerCase();
+var definePolicies = (policies, options = {}) => {
+  const declared = Array.isArray(policies) ? policies : [policies];
+  const normalize = options.normalize ?? normalizePolicyKey;
+  return {
+    policies: declared.map((policy) => {
+      for (const field of ["name", "operation", "resource"]) {
+        if (!policy[field]) {
+          throw new TypeError(
+            `definePolicies: a policy needs a \`${field}\`. Received ${JSON.stringify(policy)} \u2014 a policy missing one of the three cannot be granted, looked up, or named in a refusal.`
+          );
+        }
+      }
+      return {
+        ...policy,
+        operation: normalize(policy.operation),
+        resource: normalize(policy.resource)
+      };
+    })
+  };
+};
+var createPolicyCatalog = (options = {}) => {
+  const byName = /* @__PURE__ */ new Map();
+  return {
+    declare: (policies) => {
+      const declared = definePolicies(policies, options).policies;
+      for (const policy of declared) {
+        if (byName.has(policy.name)) {
+          throw new TypeError(
+            `policy catalogue: "${policy.name}" is already declared as ${JSON.stringify(
+              byName.get(policy.name)
+            )}. Upstream keeps these in a global object with no duplicate check, so the one that wins is decided by load order.`
+          );
+        }
+        byName.set(policy.name, policy);
+      }
+      return declared;
+    },
+    get: (name) => byName.get(name),
+    list: () => [...byName.values()],
+    operations: () => [...new Set([...byName.values()].map((policy) => policy.operation))],
+    resources: () => [...new Set([...byName.values()].map((policy) => policy.resource))]
+  };
+};
+var expandPolicies = (actions) => {
+  const byKey = /* @__PURE__ */ new Map();
+  for (const action of actions) {
+    const operations = Array.isArray(action.operation) ? action.operation : [action.operation];
+    for (const operation of operations) {
+      const key = permissionKey(action.resource, operation);
+      byKey.set(key, { key, operation, resource: action.resource });
+    }
+  }
+  return [...byKey.values()];
+};
+var grantsFor = (grants, role) => grants instanceof Map ? grants.get(role) ?? [] : grants[role] ?? [];
+var asArray = (value) => Array.isArray(value) ? value : [value];
+var policyAllows = (grants, roles, resource, operation) => roles.some((role) => {
+  const allowed = new Set(
+    expandPolicies(grantsFor(grants, role)).filter((policy) => policy.resource === resource || policy.resource === WILDCARD).map((policy) => policy.operation)
+  );
+  return allowed.has(operation) || allowed.has(WILDCARD);
+});
+var hasPermission = (input) => {
+  const roles = asArray(input.roles);
+  const actions = asArray(input.actions);
+  if (input.enabled === false) return true;
+  if (actions.length === 0) return true;
+  if (roles.length === 0) return (input.onEmptyRoles ?? "allow") === "allow";
+  return actions.every(
+    (action) => asArray(action.operation).every(
+      (operation) => policyAllows(input.grants, roles, action.resource, operation)
+    )
+  );
+};
+var resolvePermissions = (input) => {
+  const roles = asArray(input.roles);
+  if (input.enabled === false) {
+    return new Set(input.universe.map((entry) => permissionKey(entry.resource, entry.operation)));
+  }
+  if (roles.length === 0) return /* @__PURE__ */ new Set();
+  return new Set(
+    input.universe.filter((entry) => policyAllows(input.grants, roles, entry.resource, entry.operation)).map((entry) => permissionKey(entry.resource, entry.operation))
+  );
+};
+var checkPermissions = (input) => ({
+  allowed: hasPermission({ ...input, onEmptyRoles: "deny" }),
+  required: expandPolicies(asArray(input.actions)).map((policy) => policy.key)
+});
+export {
+  WILDCARD,
+  checkPermissions,
+  createPolicyCatalog,
+  definePolicies,
+  expandPolicies,
+  hasPermission,
+  normalizePolicyKey,
+  permissionKey,
+  resolvePermissions
+};

package/dist/types-DzC5zTZ8.d.ts

@@ -0,0 +1,202 @@
+/** Something a port may answer with, or answer with later. */
+type Awaitable<T> = Promise<T> | T;
+/**
+ * A schema, recognised by what it does rather than by what it is an instance of.
+ *
+ * dielime imports `z` from `@medusajs/framework/zod` under a repo rule forbidding bare `zod`, which
+ * resolves to the copy `@medusajs/deps` ships, while its own devDependency and during.day's catalog
+ * are two further copies of the same major. `value instanceof z.ZodType` compares against a class
+ * object, so a schema from another copy is not an instance of ours: such a guard passes every test
+ * written against the kit's own zod and refuses every schema a consumer hands it.
+ */
+type SchemaLike = {
+    safeParse: (value: unknown) => {
+        success: boolean;
+    };
+};
+/** What a rule is aimed at, and what a decision is being made about. */
+type PolicyScope = Record<string, unknown>;
+type PolicyQuery = PolicyScope;
+/** One authored constraint: a value, plus who said it, who it reaches and why it exists. */
+type PolicyRule = {
+    constraint: {
+        kind: string;
+        value: unknown;
+    };
+    /** Stable id — quoted in every refusal and every trace, so it has to read as prose. */
+    id: string;
+    /** May the overriding tier beat this rule? Defaults to the policy's `overridableByDefault`. */
+    overridable?: boolean;
+    /** Why this rule exists, in the words of whoever set it. Printed beside every refusal. */
+    reason: string;
+    scope?: PolicyScope;
+    tier: string;
+};
+/** One authority, in a lattice declared strongest first. */
+type PolicyTierSpec = {
+    /** Fills silence only. A promoted learning enters here and can never outrank an authority. */
+    advisory?: boolean;
+    name: string;
+    /** May the overriding tier beat a rule at this tier, when the rule itself allows it? */
+    overridable?: boolean;
+    /** This tier IS the audited escape hatch. At most one per lattice. */
+    overrides?: boolean;
+};
+/** One thing policy may constrain, and what is true of its values. */
+type PolicyKindSpec = {
+    /**
+     * Read the value this one POINTS at. Called only when `isReference` says so; answering
+     * `undefined` means the thing it points at is unset, which is a gap and not a number — the read
+     * falls through to the config layer and then to the caller's constant, and journals.
+     */
+    dereference?: (value: unknown, context: {
+        config?: PolicyConfigReader;
+        query: PolicyQuery;
+    }) => Awaitable<unknown>;
+    description?: string;
+    /** Whether this value names something else rather than holding the answer. */
+    isReference?: (value: unknown) => boolean;
+    kind: string;
+    /**
+     * Do two values of this kind say the same thing? Defaults to JSON equality.
+     *
+     * A kind whose value is a SET says so here: `['flat','on-edge']` and `['on-edge','flat']` permit
+     * the same poses, and reporting them as a conflict to "resolve explicitly" is the fastest way to
+     * teach people to ignore conflict reports.
+     */
+    sameValue?: (a: unknown, b: unknown) => boolean;
+    schema?: SchemaLike;
+};
+/** What policy decided, and the whole trace of why. */
+type PolicyDecision<V = unknown> = {
+    /** Same authority, same specificity, DIFFERENT value. Reported, never guessed. */
+    conflicts: PolicyRule[];
+    explain: string;
+    kind: string;
+    /** Set when the overriding tier beat an authority that allowed it — the audit trail. */
+    overrode?: PolicyRule;
+    /** Every other rule that reached this subject, strongest first. */
+    suppressed: PolicyRule[];
+    value: V;
+    winner: PolicyRule;
+};
+/** A rule this build cannot honour, and the reason nobody has to guess at. */
+type UnusableRule = {
+    id: string;
+    reason: string;
+};
+/** Where the authored rules come from. */
+type PolicyRuleReader = {
+    rules: (kind: string, query: PolicyQuery) => Awaitable<readonly PolicyRule[]>;
+};
+/** The layer an admin can edit. `undefined` means no value is set. */
+type PolicyConfigReader = {
+    get: (kind: string, query: PolicyQuery) => Awaitable<unknown>;
+};
+/** Where a fallback is recorded. Best-effort by contract: it may never change a decision. */
+type PolicyJournal = {
+    write: (entry: PolicyJournalEntry) => Awaitable<void>;
+};
+declare const POLICY_FALLBACK = "policy.fallback";
+declare const POLICY_INVALID_VALUE = "policy.invalid_value";
+type PolicyJournalEntry = {
+    event: typeof POLICY_FALLBACK | typeof POLICY_INVALID_VALUE;
+    /** The value that decided instead. */
+    fellBackTo: unknown;
+    kind: string;
+    /** A named operation, so repeats are countable per operation rather than per request. */
+    op?: string;
+    rejected?: {
+        reason: string;
+        value: unknown;
+    };
+    subject?: string;
+};
+/** The data half of a policy — everything the lattice needs and nothing it does not. */
+type PolicyData = {
+    kinds: readonly PolicyKindSpec[];
+    overridableByDefault: boolean;
+    rules: readonly PolicyRule[];
+    /** Vaguest first: the weight of a key is derived from where it sits. */
+    scopeKeys: readonly string[];
+    /** Strongest first. */
+    tiers: readonly PolicyTierSpec[];
+};
+type Policy = PolicyData & {
+    /** The fallbacks and unusable values this process has already recorded, keyed per boot. */
+    journalledOnce: Set<string>;
+    kindOf: (kind: string) => PolicyKindSpec | undefined;
+    rank: (tier: string) => number | undefined;
+    /** Test seam: the once-per-boot cache would otherwise leak between cases. */
+    resetJournal: () => void;
+    resolve: <V = unknown>(kind: string, query?: PolicyQuery, rules?: readonly PolicyRule[]) => PolicyDecision<V> | undefined;
+    specificity: (scope?: PolicyScope) => number;
+    tierOf: (tier: string) => PolicyTierSpec | undefined;
+    /** Kinds this build reads that no rule sets — the other half of the inert problem. */
+    unsetKinds: (rules?: readonly PolicyRule[]) => string[];
+    /** Rules scoped on a key this build does not understand — the policy is newer than the code. */
+    unsupportedScopes: (rules?: readonly PolicyRule[]) => {
+        id: string;
+        keys: string[];
+    }[];
+    unusableRules: (rules?: readonly PolicyRule[]) => UnusableRule[];
+    usableRules: (rules?: readonly PolicyRule[]) => PolicyRule[];
+};
+/** One recorded thing that happened, as the learning loop reads it. */
+type JournalObservationEntry = {
+    actor: {
+        id?: string;
+        kind: 'agent' | 'system' | 'user';
+    };
+    /** A refusal message, when the action was refused. */
+    error?: string;
+    /** Set by a reader that found no rule and used its own default. */
+    fellBackTo?: {
+        kind: string;
+        value: unknown;
+    };
+    id: string;
+    /** The event or workflow name. */
+    name: string;
+    /** A named operation this entry belongs to. */
+    op?: string;
+    /** What it happened to — an order, a company, a document. */
+    subject?: string;
+};
+/** What a read answered with, and which layer answered. */
+type PolicyReading<V> = {
+    /** Absent when no rule spoke and a lower layer decided. */
+    decision?: PolicyDecision<V>;
+    source: 'config' | 'fallback' | 'rule';
+    /** True when the caller's own compiled-in constant decided. */
+    usedFallback: boolean;
+    value: V;
+};
+/**
+ * One stored rule, in the shape both consumers' stores keep it in.
+ *
+ * Snake_case because that is what a table column is called in both, and `rule_key` rather than `id`
+ * because the surrogate id is the store's and the KEY is the rule's: it is what a refusal quotes,
+ * and what lets evidence accumulate against one rule across environments.
+ */
+type PolicyRuleRow = {
+    constraint_kind: string;
+    constraint_value: unknown;
+    overridable?: boolean | null;
+    reason: string;
+    rule_key: string;
+    scope?: Record<string, unknown> | null;
+    /** `active` | `retired`. A retired rule stays readable; it just stops deciding. */
+    status?: null | string;
+    tier: string;
+};
+/** What a store offers the kernel. Every port is optional except the rules themselves. */
+type PolicyAdapter = {
+    config?: PolicyConfigReader;
+    journal?: PolicyJournal;
+    /** For a diagnostic — a report naming "the adapter" helps nobody. */
+    name: string;
+    rule: PolicyRuleReader;
+};
+
+export { type Awaitable as A, type JournalObservationEntry as J, type PolicyQuery as P, type SchemaLike as S, type UnusableRule as U, type PolicyRuleRow as a, type PolicyAdapter as b, type PolicyKindSpec as c, type PolicyRule as d, type PolicyTierSpec as e, type Policy as f, type PolicyData as g, type PolicyDecision as h, type PolicyScope as i, type PolicyJournal as j, type PolicyConfigReader as k, type PolicyRuleReader as l, type PolicyReading as m, POLICY_FALLBACK as n, POLICY_INVALID_VALUE as o, type PolicyJournalEntry as p };

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "@geonosis/policy",
+  "version": "1.0.0",
+  "description": "A threshold is a value plus the authority that set it, the subject it reaches and the reason it exists. The precedence lattice, the rule → config → constant read with its fallback journalled once per boot, the learning loop, the generated policy prose, and a permission lattice with the runtime lifted out.",
+  "keywords": [
+    "policy",
+    "rules-engine",
+    "rbac",
+    "permissions",
+    "precedence",
+    "medusa",
+    "drizzle"
+  ],
+  "homepage": "https://github.com/microcompanies/geonosis/tree/main/packages/policy",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/microcompanies/geonosis.git",
+    "directory": "packages/policy"
+  },
+  "license": "Apache-2.0",
+  "type": "module",
+  "main": "dist/index.js",
+  "exports": {
+    ".": "./dist/index.js",
+    "./permissions": "./dist/permissions/index.js",
+    "./medusa": "./dist/medusa/index.js",
+    "./drizzle": "./dist/drizzle/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "peerDependencies": {
+    "zod": "^4.0.0"
+  },
+  "peerDependenciesMeta": {
+    "zod": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "zod": "^4.0.0"
+  },
+  "engines": {
+    "node": ">=22"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsup",
+    "typecheck": "tsc --noEmit"
+  }
+}