@xnetjs/data 0.0.2 → 0.1.0

package/dist/grant-WTQSNT5A.js

@@ -0,0 +1,8 @@
+import {
+  GrantSchema
+} from "./chunk-OSAWNZVM.js";
+import "./chunk-EBNMV2VO.js";
+import "./chunk-RL64OJJ5.js";
+export {
+  GrantSchema
+};

package/dist/grant-expiration-cleaner-CY6BcmlR.d.ts

@@ -0,0 +1,249 @@
+import { SerializedAuthorization, SerializedRoleResolver, PolicyEvaluator, DID, AuthDecision, RoleResolver, AuthDenyReason, AuthCheckInput, AuthTrace, AuthExpression } from '@xnetjs/core';
+import { a as Schema, h as NodeState, v as NodeChangeEvent, w as GrantIndex, O as OfflineAuthPolicy, D as DefinedSchema } from './types-S-BJAKyK.js';
+import { S as SchemaRegistry } from './registry-DunPv__d.js';
+
+/**
+ * Permission-matrix reflection.
+ *
+ * Turns a schema's `authorization` definition into a role × action matrix for
+ * display — the data behind a "who can do what" panel (e.g. a Permissions tab
+ * in the share dialog). This is a *structural summary* of the policy, not an
+ * evaluator: it reports which roles each action references and whether the
+ * action is public / authenticated. Actual per-subject decisions still come
+ * from the policy evaluator; per-member resolution (who holds each role) is a
+ * separate, store-backed step (see `computeRecipients`).
+ */
+
+/** How an action's expression resolves, summarized for display. */
+interface ActionPermission {
+    action: string;
+    /** Roles that grant this action (allow / bare role refs, negation-aware). */
+    roles: string[];
+    /** Roles explicitly denied (deny takes precedence at evaluation time). */
+    denied: string[];
+    /** Anyone, including anonymous, is allowed. */
+    public: boolean;
+    /** Any authenticated user is allowed. */
+    authenticated: boolean;
+}
+/** A role and a human-readable description of how a subject comes to hold it. */
+interface RoleSummary {
+    role: string;
+    /** Resolver kind: creator | property | relation | membership */
+    kind: SerializedRoleResolver['_tag'];
+    /** Human-readable provenance (e.g. "Inherited from space", "Node creator"). */
+    provenance: string;
+}
+interface PermissionMatrix {
+    /** All roles declared on the schema, with provenance. */
+    roles: RoleSummary[];
+    /** One entry per action the schema defines (in canonical order). */
+    actions: ActionPermission[];
+}
+/** Human-readable description of how a subject comes to hold a role. */
+declare function describeRoleResolver(resolver: SerializedRoleResolver): string;
+/**
+ * Build the role × action matrix for a schema's authorization. Returns an
+ * empty matrix (no roles, every action public) when the schema has no
+ * authorization — an unauthorized schema is open by construction.
+ */
+declare function buildPermissionMatrix(authorization: SerializedAuthorization | undefined): PermissionMatrix;
+
+/**
+ * Derive the hub's grant-action expectations from a schema's authorization
+ * block (exploration 0192).
+ *
+ * The hub enforces access with a grant model whose vocabulary is
+ * `read | comment | write | share | admin` (see `spaceRoleGrantActions`). The
+ * schema authorization DSL speaks `read | write | delete | share`. These two
+ * have historically been maintained by hand in separate places and were free
+ * to drift. `schemaToHubPolicy` projects a schema's declared per-action role
+ * sets onto the hub vocabulary so the relationship can be asserted in CI
+ * (`hub-policy.test.ts`) — the schema authorization block becomes the single
+ * declarative source the hub mapping is checked against.
+ *
+ * Correspondence:
+ *   read   → read     write → write     share → share     delete → admin
+ *
+ * `comment` is a hub-only refinement of `read` (a commenter may annotate but
+ * not edit). The Space cascade folds commenters into `read` and does not model
+ * a distinct `comment` action, so it is intentionally absent here.
+ */
+
+interface HubPolicy {
+    /** For each role declared by the schema, the hub grant actions it implies. */
+    roleActions: Record<string, string[]>;
+    /** True when the schema's `read` action grants PUBLIC. */
+    public: boolean;
+}
+/** Project a schema's authorization block onto the hub grant-action model. */
+declare function schemaToHubPolicy(schema: Schema): HubPolicy;
+/**
+ * Hub grant actions a Space *member* with the given Space role inherits on a
+ * node governed by the Space cascade, derived purely from the schema. A member
+ * with role `R` resolves to the cascade role `spaceR` (e.g. `viewer` →
+ * `spaceViewer`), so this looks up that role's projected hub actions.
+ *
+ * Used by the parity test to prove the cascade and `spaceRoleGrantActions`
+ * agree, so neither can change without the other.
+ */
+declare function hubActionsForSpaceRole(schema: Schema, spaceRole: string): string[];
+
+interface NodeStoreReader {
+    get(id: string): Promise<NodeState | null>;
+    list(options?: {
+        schemaId?: string;
+        includeDeleted?: boolean;
+    }): Promise<NodeState[]>;
+    subscribe(listener: (event: NodeChangeEvent) => void): () => void;
+}
+interface DecisionCacheOptions {
+    ttlMs?: number;
+    maxSize?: number;
+    now?: () => number;
+}
+declare class DecisionCache {
+    private cache;
+    private ttlMs;
+    private readonly maxSize;
+    private readonly now;
+    constructor(options?: DecisionCacheOptions);
+    get(subject: DID, action: string, nodeId: string): AuthDecision | null;
+    set(subject: DID, action: string, nodeId: string, decision: AuthDecision): void;
+    invalidateNode(nodeId: string): void;
+    invalidateSubject(did: DID): void;
+    clear(): void;
+    setTTL(ttlMs: number): void;
+    private key;
+}
+interface DefaultRoleResolverOptions {
+    maxDepth?: number;
+    maxNodes?: number;
+}
+declare class DefaultRoleResolver {
+    private readonly store;
+    private readonly schemaRegistry;
+    private readonly maxDepth;
+    private readonly maxNodes;
+    constructor(store: NodeStoreReader, schemaRegistry: SchemaRegistry, options?: DefaultRoleResolverOptions);
+    resolveRoles(did: DID, node: NodeState, schema: Schema): Promise<Set<string>>;
+    resolveRoleMembers(resolver: RoleResolver, node: NodeState): Promise<DID[]>;
+    private resolveRoleMembersInner;
+    private checkRole;
+    private membershipMatchesContainer;
+    /**
+     * The node's own id plus the ids of every ancestor reachable by walking
+     * `parentProp`. Cycle- and depth-bounded. When `parentProp` is undefined the
+     * set is just the node itself (no inheritance).
+     */
+    private collectContainerIds;
+    private loadRelatedNodes;
+}
+declare function evaluateExpression(expr: AuthExpression, roles: Set<string>, isAuthenticated: boolean): boolean;
+interface DefaultPolicyEvaluatorOptions {
+    store: NodeStoreReader;
+    schemaRegistry: SchemaRegistry;
+    grantIndex?: GrantIndex;
+    cache?: DecisionCache;
+    roleResolver?: DefaultRoleResolver;
+    maxDepth?: number;
+    maxNodes?: number;
+    now?: () => number;
+    offlinePolicy?: Partial<OfflineAuthPolicy>;
+    getLastSyncedAt?: () => number;
+    isOnline?: () => boolean;
+    onRevalidation?: (event: RevalidationEvent) => void;
+    onDecision?: (event: AuthDecisionEvent) => void;
+}
+interface RevalidationEvent {
+    type: 'hybrid-revalidation';
+    at: number;
+    invalidated: 'all';
+}
+interface AuthDecisionEvent {
+    type: 'auth:decision';
+    timestamp: number;
+    subject: DID;
+    action: AuthDecision['action'];
+    resource: string;
+    allowed: boolean;
+    cached: boolean;
+    roles: string[];
+    reasons: AuthDenyReason[];
+    duration: number;
+}
+declare class DefaultPolicyEvaluator implements PolicyEvaluator {
+    private readonly options;
+    private readonly grantIndex?;
+    private readonly cache;
+    private readonly roleResolver;
+    private readonly now;
+    private offlinePolicy;
+    private readonly getLastSyncedAt?;
+    private readonly isOnline;
+    private readonly onRevalidation?;
+    private readonly onDecision?;
+    private lastConnectivityOnline;
+    constructor(options: DefaultPolicyEvaluatorOptions);
+    can(input: AuthCheckInput): Promise<AuthDecision>;
+    explain(input: AuthCheckInput): Promise<AuthTrace>;
+    invalidate(nodeId: string): void;
+    invalidateSubject(did: DID): void;
+    getOfflinePolicy(): OfflineAuthPolicy;
+    setOfflinePolicy(patch: Partial<OfflineAuthPolicy>): void;
+    handleConnectivityChange(isOnline: boolean): void;
+    private findMatchingGrant;
+    private checkFieldRules;
+    private decision;
+    private deny;
+    private loadNodeFromInput;
+    private isAuthStateStale;
+    private emitDecision;
+}
+declare function createPolicyEvaluator(options: {
+    store: NodeStoreReader;
+    schemaRegistry: SchemaRegistry;
+    grantSchemaId?: string;
+    cache?: DecisionCache;
+    maxDepth?: number;
+    maxNodes?: number;
+}): Promise<DefaultPolicyEvaluator>;
+type SchemaRegistryReader = Pick<SchemaRegistry, 'get'>;
+type DefinedSchemaLike = DefinedSchema;
+
+interface GrantExpirationStore {
+    list(options?: {
+        schemaId?: string;
+        includeDeleted?: boolean;
+    }): Promise<Array<{
+        id: string;
+        properties: Record<string, unknown>;
+    }>>;
+    update(nodeId: string, options: {
+        properties: Record<string, unknown>;
+    }): Promise<unknown>;
+}
+interface GrantExpirationCleanerOptions {
+    clock?: () => number;
+    cleanupIntervalMs?: number;
+    clockSkewToleranceMs?: number;
+    systemRevoker?: string;
+}
+declare class GrantExpirationCleaner {
+    private readonly store;
+    static readonly DEFAULT_CLOCK_SKEW_TOLERANCE_MS = 60000;
+    static readonly DEFAULT_CLEANUP_INTERVAL_MS: number;
+    private readonly clock;
+    private readonly cleanupIntervalMs;
+    private readonly clockSkewToleranceMs;
+    private readonly systemRevoker;
+    private timer;
+    constructor(store: GrantExpirationStore, options?: GrantExpirationCleanerOptions);
+    start(): void;
+    stop(): void;
+    cleanup(): Promise<{
+        pruned: number;
+    }>;
+}
+
+export { type ActionPermission as A, DefaultPolicyEvaluator as D, GrantExpirationCleaner as G, type HubPolicy as H, type NodeStoreReader as N, type PermissionMatrix as P, type RoleSummary as R, type SchemaRegistryReader as S, DefaultRoleResolver as a, DecisionCache as b, buildPermissionMatrix as c, describeRoleResolver as d, evaluateExpression as e, createPolicyEvaluator as f, type DecisionCacheOptions as g, hubActionsForSpaceRole as h, type DefaultRoleResolverOptions as i, type DefaultPolicyEvaluatorOptions as j, type DefinedSchemaLike as k, type RevalidationEvent as l, type AuthDecisionEvent as m, type GrantExpirationStore as n, type GrantExpirationCleanerOptions as o, schemaToHubPolicy as s };

package/dist/import-batch-IXBJLQPJ.js

@@ -0,0 +1,12 @@
+import {
+  IMPORT_BATCH_SCHEMA_IRI,
+  ImportBatchSchema
+} from "./chunk-VQ7JHB67.js";
+import "./chunk-OCMSAKWV.js";
+import "./chunk-T5AZAOG5.js";
+import "./chunk-EBNMV2VO.js";
+import "./chunk-RL64OJJ5.js";
+export {
+  IMPORT_BATCH_SCHEMA_IRI,
+  ImportBatchSchema
+};

package/dist/inbox-state-E5NSVOGP.js

@@ -0,0 +1,12 @@
+import {
+  DEFAULT_CHANNEL_TIER,
+  InboxStateSchema,
+  inboxStateNodeId
+} from "./chunk-YEFKQYKA.js";
+import "./chunk-EBNMV2VO.js";
+import "./chunk-RL64OJJ5.js";
+export {
+  DEFAULT_CHANNEL_TIER,
+  InboxStateSchema,
+  inboxStateNodeId
+};