@eminuckan/spine 0.2.2 → 0.3.0

package/CHANGELOG.md

@@ -2,6 +2,48 @@
 
 All notable changes to this project will be documented in this file.
 
+## [Unreleased]
+
+No unreleased changes.
+
+## [0.3.0] - 2026-06-01
+
+### Added
+
+- Added a public-surface check that blocks private project names and app-specific authorization hints from the public package.
+- Added per-login allowlists for app-specific OIDC authorization parameters and public state UI context.
+- Added Keycloak-compatible back-channel and front-channel logout handlers.
+- Added Redis session indexes by user, OIDC `sid`, and legacy `session_state`.
+- Added session listing and destroy primitives for current-user, all-user, `sid`, and `session_state` cleanup.
+- Added OIDC client authentication method configuration for public and confidential clients.
+- Added generic tenant, identity, permission, access, and API configuration surfaces for custom SaaS backend contracts.
+- Added Vitest coverage for authorization parameters, access evaluation, permissions, tenant state, identity state, and API header configuration.
+- Added React Router SaaS example app, installation docs, adapter docs, roadmap, maintainer notes, and Codex maintenance plan.
+- Added an adapter request issue template for framework and provider integrations.
+
+### Changed
+
+- Switched server-side auth from direct `oauth4webapi` calls to `openid-client`.
+- Removed built-in product-flow redirects from route protection; consuming apps now own all setup, billing, and tenant workflow routing through `configureRouteProtection`.
+- Changed built-in package defaults from legacy project branding to Spine-oriented defaults.
+- Made default logout RP-Initiated Logout and kept app-local cleanup explicit with `logout=local`.
+- Removed `offline_access` from the default scope; apps can opt in explicitly if they need long-lived refresh tokens.
+- Updated CI and release validation to run the full `pnpm check` gate.
+
+## [0.2.4] - 2026-04-25
+
+### Fixed
+
+- Allow HTTP OIDC requests for localhost issuers in non-production environments.
+- Keep insecure OIDC requests disabled unconditionally in production.
+
+## [0.2.3] - 2026-04-25
+
+### Fixed
+
+- Added richer OIDC discovery diagnostics, including the resolved discovery URL.
+- Avoid sending stale `id_token_hint` values to a new OIDC provider during provider migrations.
+
 ## [0.2.0] - 2026-03-15
 
 ### Added

package/CODE_OF_CONDUCT.md

@@ -0,0 +1,39 @@
+# Code of Conduct
+
+## Our Pledge
+
+We want Spine to be a welcoming project for contributors of all experience levels. We commit to making participation respectful, constructive, and harassment-free.
+
+## Our Standards
+
+Examples of behavior that help create a positive environment:
+
+- Being respectful in language and tone
+- Giving actionable, kind feedback
+- Accepting good-faith disagreement
+- Prioritizing shared understanding over ego
+- Helping newer contributors learn the codebase
+
+Examples of unacceptable behavior:
+
+- Harassment or discrimination
+- Personal attacks
+- Trolling or deliberately hostile behavior
+- Publishing private information without permission
+- Repeatedly derailing technical discussions
+
+## Enforcement
+
+Project maintainers are responsible for clarifying and enforcing this code of conduct. They may remove, edit, or reject comments, commits, issues, pull requests, and other contributions that violate these standards.
+
+## Reporting
+
+If you experience or witness unacceptable behavior, open a private report to the maintainer at `eminuckan@gmail.com`.
+
+## Scope
+
+This code of conduct applies within project spaces and in public spaces when someone is representing the project.
+
+## Attribution
+
+This document is inspired by the Contributor Covenant and adapted for this project.

package/CONTRIBUTING.md

@@ -0,0 +1,78 @@
+# Contributing to Spine
+
+Thanks for contributing.
+
+Spine is intended to be a reusable foundation for SaaS infrastructure, so changes should optimize for clarity, composability, and portability across products.
+
+## Before You Start
+
+- Read [README.md](README.md)
+- Read [docs/architecture.md](docs/architecture.md)
+- Read [docs/backend-adaptation.md](docs/backend-adaptation.md)
+- Check existing issues and pull requests first
+
+## Local Setup
+
+```bash
+pnpm install
+pnpm check
+```
+
+## Project Structure
+
+| Path | Purpose |
+| --- | --- |
+| `src/auth` | OAuth, sessions, token refresh, route protection |
+| `src/tenant` | Tenant store, provider, cookie, and server helpers |
+| `src/identity` | Identity cache, client store, and provider |
+| `src/permissions` | Permission store, hooks, components, and server protection |
+| `src/api-client` | API config factory, fetch middleware, and retry/error helpers |
+| `src/query-client` | TanStack Query defaults and utilities |
+| `src/signalr` | Realtime client primitives |
+| `src/logging` | Logging utilities |
+| `src/react-router` | React Router adapter entry points |
+| `docs` | Project documentation |
+
+## Contribution Rules
+
+- Keep core modules framework-agnostic unless the file is inside an adapter namespace
+- Prefer configuration hooks over hardcoded product behavior
+- Avoid shipping product-specific routes, claim names, endpoint paths, or UI assumptions into core
+- Keep public APIs small and explicit
+- Update documentation when behavior or public APIs change
+- Add or update changelog entries for user-visible changes
+
+## Adapter Philosophy
+
+When deciding where code should live:
+
+- Put it in core if it can work across multiple apps with configuration
+- Put it in an adapter if it depends on framework primitives
+- Keep it in the consuming app if it expresses product policy
+
+Examples:
+
+- Good for core: token refresh, tenant cookie utilities, permission checks, identity caching
+- Good for adapters: framework-specific redirects, loader wrappers, request helpers
+- Good for apps: setup redirects, entitlement gating, domain permission constants
+
+## Pull Request Checklist
+
+- `pnpm check` passes
+- Public API changes are documented
+- Changelog is updated when needed
+- No product-specific behavior leaked into core without a configuration escape hatch
+
+## Commit Messages
+
+Use concise, English commit messages.
+
+Examples:
+
+- `docs: rewrite README for open source release`
+- `feat: add configurable permission route protection`
+- `refactor: move tenant cookie policy into core config`
+
+## Release Notes
+
+Maintainers should also read [docs/releasing.md](docs/releasing.md).

package/MAINTAINERS.md

@@ -0,0 +1,43 @@
+# Maintainers
+
+## Current Maintainer
+
+- Muhammet Emin Uckan, primary maintainer
+
+## Maintainer Responsibilities
+
+The maintainer owns:
+
+- reviewing issues and pull requests
+- keeping the package installable and documented
+- preserving the boundary between Spine core, framework adapters, and consuming apps
+- coordinating security reports
+- preparing releases and changelog entries
+- validating changes with `pnpm check` and package dry runs
+
+## Review Policy
+
+Changes should be reviewed against these questions:
+
+- Does this solve a repeated SaaS infrastructure problem?
+- Can it work across multiple apps without product-specific naming?
+- Is the core still framework-agnostic?
+- Does this belong in core, a framework adapter, provider guidance, or the app?
+- Are public API changes documented and covered by tests?
+
+## Release Policy
+
+Spine follows semver. While the package is on a `0.x` line, breaking changes may still happen, but they must be documented and kept migration-friendly where practical.
+
+Before publishing:
+
+```bash
+pnpm check
+npm pack --dry-run
+```
+
+## Codex-Assisted Maintenance
+
+Codex may be used to help with issue triage, pull request review, release checks, documentation updates, and security hardening. The maintainer remains responsible for all final decisions, shipped code, and release artifacts.
+
+See [docs/codex-maintenance.md](docs/codex-maintenance.md) for the operating plan.

package/README.md

@@ -1,5 +1,9 @@
 # Spine
 
+[![CI](https://github.com/eminuckan/spine/actions/workflows/ci.yml/badge.svg)](https://github.com/eminuckan/spine/actions/workflows/ci.yml)
+[![npm version](https://img.shields.io/npm/v/%40eminuckan%2Fspine.svg)](https://www.npmjs.com/package/@eminuckan/spine)
+[![license: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
+
 Framework-agnostic SaaS primitives for authentication, identity, permissions, multi-tenancy, API access, realtime events, query configuration, and logging.
 
 Spine is designed around one idea: the reusable parts of a SaaS platform should live in a single package, while application policy and framework quirks should stay in thin adapters. Today the package ships a framework-agnostic core plus a React Router adapter surface. Future adapters can follow the same pattern.
@@ -10,6 +14,7 @@ Spine is designed around one idea: the reusable parts of a SaaS platform should
 - Current adapter: `@eminuckan/spine/react-router`
 - Server primitives use Web `Request`/`Response` objects, not framework-specific response helpers
 - React Router adapter is intentionally thin today so other adapters can be added without changing the core contract
+- Extracted from repeated production-facing SaaS frontend infrastructure needs, then rebooted as an independent OSS package
 
 ## Why Spine
 
@@ -28,7 +33,7 @@ Spine aims to be:
 - Core before adapter: framework-specific behavior belongs in dedicated adapter entry points
 - Configure, do not fork: backend claim names, cookie behavior, endpoints, and redirects should be configured first
 - Request/Response first: server modules should work anywhere a standard Web `Request` and `Response` exist
-- App policy stays local: onboarding flows, subscription gates, product-specific redirects, and permission taxonomies should live in the consuming app
+- App policy stays local: setup flows, entitlement gates, product-specific redirects, and permission taxonomies should live in the consuming app
 - Open for composition: apps should be able to wrap Spine primitives instead of rewriting them
 
 ## Package Surfaces
@@ -54,8 +59,9 @@ Spine aims to be:
 
 ## What Spine Includes
 
-- OAuth2/OIDC login, callback handling, logout, and token refresh
-- Redis-backed session and OAuth state storage
+- OpenID Connect login, callback handling, RP-Initiated Logout, and token refresh
+- Redis-backed session and OAuth state storage with user/session indexes
+- Keycloak-compatible front-channel and back-channel logout handlers
 - Server-side route protection primitives
 - Server-side permission route protection configuration
 - Multi-tenant client state and server helpers
@@ -67,8 +73,8 @@ Spine aims to be:
 
 ## What Spine Does Not Include
 
-- Your product's onboarding rules
-- Your product's subscription rules
+- Your product's setup rules
+- Your product's billing or entitlement rules
 - Your product's permission vocabulary
 - Your backend DTOs or generated API clients
 - Your page structure, layouts, or UI system
@@ -107,24 +113,75 @@ If you use client-side React features, install peer dependencies too:
 pnpm add react @tanstack/react-query
 ```
 
+For a fuller setup path, see [docs/installation.md](docs/installation.md).
+
+## Try the Example App
+
+```bash
+cd examples/react-router-saas
+pnpm install
+cp .env.example .env
+pnpm dev
+```
+
+The example includes React Router auth routes, a protected dashboard loader, client provider wiring, and local app adapters for backend identity and tenant conventions.
+
 ## Environment Variables
 
 The built-in auth/session layer currently reads these environment variables:
 
 | Variable | Required | Purpose |
 | --- | --- | --- |
-| `OIDC_AUTHORITY` | Yes | OAuth/OIDC issuer base URL |
+| `OIDC_AUTHORITY` | Yes | OpenID Connect issuer base URL |
 | `OIDC_CLIENT_ID` | Yes | Client identifier |
-| `OIDC_REDIRECT_URI` | Yes | OAuth callback URL |
+| `OIDC_REDIRECT_URI` | Yes | OIDC callback URL |
 | `OIDC_CLIENT_SECRET` | No | Client secret for confidential clients |
-| `OIDC_SCOPE` | No | Requested scope string |
+| `OIDC_CLIENT_AUTH_METHOD` | No | `none`, `client_secret_post`, or `client_secret_basic` |
+| `OIDC_SCOPE` | No | Requested scope string. Defaults to `openid profile email api` |
 | `OIDC_POST_LOGOUT_REDIRECT_URI` | No | Logout return URL |
 | `OIDC_APPLICATION_TYPE` | No | `no-landing-page`, `landing-page`, or legacy aliases |
-| `OIDC_SSO_LOGOUT` | No | Explicit full-logout override |
 | `OIDC_HAS_LANDING_PAGE` | No | Explicit landing-page behavior override |
+| `OIDC_ALLOW_INSECURE_REQUESTS` | No | Allows non-HTTPS OIDC issuer calls only outside production |
 | `REDIS_URL` | No | Redis connection string for sessions and OAuth state |
 | `REDIS_KEY_PREFIX` | No | Prefix for Redis keys |
-| `API_BASE_URL` | No | Default API base URL for `createAPIConfigFactory` |
+| `API_BASE_URL` | No | Optional fallback API base URL for `createAPIConfigFactory` |
+
+## OIDC Session Lifecycle
+
+Spine treats the OIDC provider as the identity/session authority and the app as a relying party with its own Redis session. The default logout behavior follows RP-Initiated Logout:
+
+- `/auth/logout` clears the current app session and redirects to the provider end-session endpoint.
+- `/auth/logout?logout=local` clears only the current app session. Use this for automatic cleanup after token refresh failure or expired local state.
+- `/auth/logout?logout=all` revokes all known app sessions for the current user, clears their Redis session indexes, and then redirects to the provider end-session endpoint.
+
+For Keycloak clients, wire the provider logout callbacks to thin app routes that call Spine:
+
+```ts
+// app/routes/auth/backchannel-logout.ts
+import { handleBackChannelLogout } from '@eminuckan/spine/react-router/server';
+
+export async function action({ request }: { request: Request }) {
+  return handleBackChannelLogout(request);
+}
+```
+
+```ts
+// app/routes/auth/frontchannel-logout.ts
+import { handleFrontChannelLogout } from '@eminuckan/spine/react-router/server';
+
+export async function loader({ request }: { request: Request }) {
+  return handleFrontChannelLogout(request);
+}
+```
+
+In Keycloak, configure the client with:
+
+- Backchannel Logout URL: `https://your-app.example.com/auth/backchannel-logout`
+- Backchannel Logout Session Required: enabled
+- Frontchannel Logout URL: `https://your-app.example.com/auth/frontchannel-logout`
+- Frontchannel Logout Session Required: enabled
+
+Back-channel logout verifies the signed `logout_token` against the provider JWKS and destroys sessions by `sid` or `sub`. Front-channel logout validates `iss` and destroys sessions by `sid` when Keycloak sends it.
 
 ## Quick Start
 
@@ -133,7 +190,7 @@ The built-in auth/session layer currently reads these environment variables:
 Spine's server modules are generic, so your app should provide backend-specific fetchers once.
 
 ```ts
-// app/lib/mimir/identity.server.ts
+// app/lib/spine/identity.server.ts
 import {
   configureIdentityAPIFetcher,
   configurePermissionFetcher,
@@ -143,7 +200,6 @@ import {
 import { createAPIConfigFactory } from '@eminuckan/spine/api-client/server';
 import { getAccessToken } from '@eminuckan/spine/react-router/server';
 import { getCurrentTenant } from '@eminuckan/spine/tenant/server';
-import { Configuration, IdentityApi } from '~/lib/api-clients/api';
 
 const { createAPIConfig } = createAPIConfigFactory(getAccessToken, getCurrentTenant);
 
@@ -153,47 +209,38 @@ configureIdentityAPIFetcher(async (request) => {
     includeAuth: true,
   });
 
-  const api = new IdentityApi(
-    new Configuration({
-      basePath: config.basePath,
-      accessToken: config.accessToken,
-      baseOptions: { headers: config.headers },
-    })
-  );
+  const response = await fetch(`${config.basePath}/api/me/context`, {
+    headers: config.headers,
+  });
 
-  const response = await api.identityGetMyContext();
+  if (!response.ok) {
+    throw new Error(`Failed to load identity context: ${response.status}`);
+  }
 
-  return {
-    ...response.data,
-    contextVersion: Date.now(),
-    hasSubscription: Boolean(
-      response.data.onboarding?.subscription?.exists &&
-      ['active', 'trialing'].includes(response.data.onboarding?.subscription?.status || '')
-    ),
-  };
+  return response.json();
 });
 
 configurePermissionFetcher(async (request, tenantId) => {
   const config = await createAPIConfig(request, { requireTenant: false });
-  const api = new IdentityApi(
-    new Configuration({
-      basePath: config.basePath,
-      accessToken: config.accessToken,
-      baseOptions: { headers: config.headers },
-    })
-  );
+  const response = await fetch(`${config.basePath}/api/me/permissions?tenantId=${tenantId}`, {
+    headers: config.headers,
+  });
 
-  const response = await api.identityGetMyPermissions(tenantId);
-  return response.data.permissions || [];
+  if (!response.ok) {
+    return [];
+  }
+
+  const payload = await response.json();
+  return payload.permissions || [];
 });
 
 export { contextToUserInfo, getIdentityContext };
 ```
 
 ```ts
-// app/lib/mimir/tenant.server.ts
+// app/lib/spine/tenant.server.ts
 import {
-  configureIdentityContextFetcher,
+  configureTenantResolution,
   configureTenantCookie,
   getAvailableTenants,
   getCurrentTenant,
@@ -206,7 +253,9 @@ configureTenantCookie({
   sameSite: 'Lax',
 });
 
-configureIdentityContextFetcher(fetchIdentityContext);
+configureTenantResolution({
+  identityContextFetcher: fetchIdentityContext,
+});
 
 export {
   getAvailableTenants,
@@ -218,7 +267,7 @@ export {
 ### 2. Configure Server-Side Permission Protection
 
 ```ts
-// app/lib/mimir/permissions.server.ts
+// app/lib/spine/permissions.server.ts
 import {
   configurePermissionRouteProtection,
   requirePermission,
@@ -256,8 +305,8 @@ export { requirePermission };
 ```ts
 // app/routes/_protected.tsx
 import { authRoute, getAccessToken } from '@eminuckan/spine/react-router/server';
-import { getCurrentTenant, initializeTenant } from '~/lib/mimir/tenant.server';
-import { contextToUserInfo, getIdentityContext } from '~/lib/mimir/identity.server';
+import { getCurrentTenant, initializeTenant } from '~/lib/spine/tenant.server';
+import { contextToUserInfo, getIdentityContext } from '~/lib/spine/identity.server';
 
 export async function loader({ request }: { request: Request }) {
   return authRoute(request, async (user) => {
@@ -349,10 +398,10 @@ import {
 } from '@eminuckan/spine/server';
 
 configureAuthClaimMapping({
-  tenantIds: ['organizations', 'tenant_ids'],
-  tenantRoles: ['organization_roles', 'tenant_roles'],
+  tenantIds: ['tenant_ids'],
+  tenantRoles: ['tenant_roles'],
   permissions: ['permissions', 'scope'],
-  isOnboarded: ['profile_complete', 'is_onboarded'],
+  isOnboarded: ['is_onboarded'],
 });
 
 configureIdentityStore({
@@ -366,17 +415,24 @@ configureRouteProtection({
 });
 ```
 
+Client contracts are configurable too. Simple apps can use endpoint configuration; apps with workspace/account/customer-specific contracts can provide `fetchTenantData`, `switchTenant`, `fetchContext`, and `fetchPermissions` functions. API header names are configurable through `createAPIConfigFactory`.
+
 More adaptation examples live in [docs/backend-adaptation.md](docs/backend-adaptation.md).
 
 ## Module Guides
 
 - [Architecture](docs/architecture.md)
+- [Installation](docs/installation.md)
 - [Adapters](docs/adapters.md)
 - [Backend Adaptation](docs/backend-adaptation.md)
 - [Module Reference](docs/module-reference.md)
+- [Roadmap](ROADMAP.md)
+- [Codex Maintenance Plan](docs/codex-maintenance.md)
 - [Releasing](docs/releasing.md)
 - [Contributing](CONTRIBUTING.md)
+- [Maintainers](MAINTAINERS.md)
 - [Security](SECURITY.md)
+- [Code of Conduct](CODE_OF_CONDUCT.md)
 
 ## Current Boundaries
 
@@ -391,27 +447,27 @@ Spine already owns the reusable infrastructure for:
 
 Consuming apps should still own:
 
-- Product-specific onboarding pages and redirects
-- Product-specific subscription policies
+- Product-specific setup pages and redirects
+- Product-specific billing or entitlement policies
 - Permission constants and domain vocabulary
 - Generated API clients
 - UI-specific wrappers and design system components
 
 ## Roadmap
 
+The active roadmap lives in [ROADMAP.md](ROADMAP.md). Current tracks include:
+
 - First-class Next.js adapter surface
-- More adapter authoring guidance
-- Cleaner permission taxonomy extension story
-- More example apps
-- Broader runtime coverage tests
+- Clerk and Supabase integration guidance
+- More adapter authoring tests and examples
+- Cleaner migration from deprecated compatibility aliases
+- Public API stability review before `1.0`
 
 ## Development
 
 ```bash
 pnpm install
-pnpm typecheck
-pnpm build
-pnpm lint
+pnpm check
 ```
 
 Detailed contributor guidance lives in [CONTRIBUTING.md](CONTRIBUTING.md).

package/ROADMAP.md

@@ -0,0 +1,58 @@
+# Spine Roadmap
+
+Spine is a small, adapter-friendly foundation for SaaS frontend infrastructure. The roadmap favors reusable primitives, clear framework adapters, and backend-contract flexibility over product-specific features.
+
+## Current Focus
+
+- Keep the core framework-agnostic and based on Web `Request` and `Response` primitives.
+- Keep application policy, permission vocabularies, setup flows, and entitlement rules in consuming apps.
+- Make every backend convention configurable before adding a new abstraction.
+- Preserve compatibility for existing consumers while moving toward a cleaner `1.0` API.
+
+## Near-Term
+
+- Publish the `0.3.x` open source reboot with generic tenant, identity, permission, API, realtime, and adapter surfaces.
+- Expand the React Router example into a fuller SaaS shell with auth, tenant switching, permission gates, and API configuration.
+- Add adapter authoring tests that prove new adapters can stay thin.
+- Add more normalization examples for account, workspace, organization, and custom tenant contracts.
+- Document migration notes from deprecated organization and subscription aliases to tenant and entitlement terminology.
+
+## Adapter Track
+
+- First-class Next.js adapter entry points.
+- React Router adapter refinements where framework-specific helpers remove real boilerplate.
+- Research notes for Vue and Svelte adapter shapes.
+- Adapter request template and contribution checklist for community proposals.
+
+## Provider Track
+
+- Clerk identity/session adapter guidance.
+- Supabase auth and Postgres-backed tenant examples.
+- Auth0 and generic OpenID Connect recipes.
+- Optional examples for API clients generated from OpenAPI without making any generated client mandatory.
+
+## Core Hardening
+
+- Broader tests for route protection and OIDC/session lifecycle behavior.
+- More explicit storage abstraction boundaries for sessions and OAuth state.
+- Runtime compatibility notes for Node, edge-like runtimes, and serverless deployments.
+- Public API stability review before `1.0`.
+
+## Not Planned For Core
+
+- Product-specific route names.
+- Product-specific permission constants.
+- Billing plan vocabulary.
+- Backend DTOs or generated SDKs.
+- UI components tied to one design system.
+
+Those belong in consuming apps or app-specific adapter packages.
+
+## How To Propose Work
+
+Open an issue using the relevant template and describe:
+
+- the repeated SaaS infrastructure problem
+- whether it belongs in core, a framework adapter, provider guidance, or the consuming app
+- how the API can remain generic across multiple projects
+- what tests or docs would prove the behavior

package/SECURITY.md

@@ -0,0 +1,37 @@
+# Security Policy
+
+## Supported Versions
+
+Security fixes are applied to the latest published release line.
+
+## Reporting a Vulnerability
+
+Please do not open public GitHub issues for security problems.
+
+Instead, report vulnerabilities privately to:
+
+- Email: `eminuckan@gmail.com`
+
+When possible, include:
+
+- A clear description of the issue
+- Affected versions
+- Reproduction steps
+- Potential impact
+- Any suggested mitigation
+
+## Response Expectations
+
+The goal is to acknowledge reports quickly, validate impact, and coordinate a fix before public disclosure.
+
+## Scope Notes
+
+Spine provides infrastructure primitives, but consuming applications are still responsible for:
+
+- Backend authorization enforcement
+- Secure secret management
+- Correct adapter configuration
+- Safe redirect and cookie policies
+- Protecting product-specific APIs and workflows
+
+Frontend permission checks and route guards in Spine improve UX, but they are not a substitute for backend authorization.

package/dist/access/evaluator.d.ts

@@ -0,0 +1,3 @@
+import type { AccessDecision, AccessRequirement, AccessSubject } from './types';
+export declare function evaluateAccessRequirement(requirement: AccessRequirement | null | undefined, subject: AccessSubject): AccessDecision;
+//# sourceMappingURL=evaluator.d.ts.map

package/dist/access/evaluator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"evaluator.d.ts","sourceRoot":"","sources":["../../src/access/evaluator.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,cAAc,EAGd,iBAAiB,EACjB,aAAa,EAEd,MAAM,SAAS,CAAC;AA0CjB,wBAAgB,yBAAyB,CACvC,WAAW,EAAE,iBAAiB,GAAG,IAAI,GAAG,SAAS,EACjD,OAAO,EAAE,aAAa,GACrB,cAAc,CAqDhB"}

package/dist/access/index.d.ts

@@ -0,0 +1,3 @@
+export type { AccessDecision, AccessDeniedReason, AccessOperator, AccessRequirement, AccessSubject, SubscriptionAccessSnapshot, } from './types';
+export { evaluateAccessRequirement } from './evaluator';
+//# sourceMappingURL=index.d.ts.map

package/dist/access/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/access/index.ts"],"names":[],"mappings":"AAAA,YAAY,EACV,cAAc,EACd,kBAAkB,EAClB,cAAc,EACd,iBAAiB,EACjB,aAAa,EACb,0BAA0B,GAC3B,MAAM,SAAS,CAAC;AACjB,OAAO,EAAE,yBAAyB,EAAE,MAAM,aAAa,CAAC"}

package/dist/access/index.js

@@ -0,0 +1,4 @@
+import "../permission-service-CvGpwI0d.js";
+import { evaluateAccessRequirement } from "../access-CGrsDMwu.js";
+
+export { evaluateAccessRequirement };