@qlzt/dsh-api-remote-access 0.0.0-stage → 0.2.1-rc.2

package/lib/types/index.js

@@ -0,0 +1,405 @@
+/**
+ * Host method-level access control. The Gateway asks `decide()` before it
+ * dispatches a non-owner call or forwards an event to a non-owner Peer; list
+ * methods filter items through `allows()`; every Peer reads its own access
+ * snapshot, first from the index and then from `follow()`. Business packages
+ * register one policy per non-owner principal kind.
+ * @module @qlzt/dsh-api-remote-access
+ */
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+import { Remote, TypertRemoteService, principalOf, } from '@qlzt/dsh-typert-protocol';
+import { REMOTE_ACCESS_SNAPSHOT_KEY } from "./snapshot.js";
+export { REMOTE_ACCESS_SNAPSHOT_KEY } from "./snapshot.js";
+/** The snapshot endpoint every Peer may read for itself. */
+const FOLLOW_ACTION = 'remoteAccess/follow';
+const ALLOW = Object.freeze({ kind: 'allow' });
+const NO_ALLOW = Object.freeze({ kind: 'deny', reason: 'no-allow' });
+const POLICY_FAILED = Object.freeze({ kind: 'deny', reason: 'policy-failed' });
+const OWNER = Object.freeze({ kind: 'owner' });
+const OWNER_BASELINE = Object.freeze({ type: 'baseline', owner: true });
+const ALLOWED = Object.freeze({ kind: 'allow' });
+const FAILED = Object.freeze({ kind: 'failed' });
+/** One open non-owner snapshot generation; changes coalesce until its reader wakes. */
+class AccessFollower {
+    principal;
+    dirty = false;
+    wake;
+    /** @param principal - the generation's caller identity; never the owner. */
+    constructor(principal) {
+        this.principal = principal;
+    }
+    /** Mark the generation stale and wake its reader. */
+    touch() {
+        this.dirty = true;
+        this.wake?.();
+    }
+    /**
+     * Wait until the generation is stale or cancelled.
+     * @param signal - generation cancellation.
+     * @returns true when stale; false once cancelled.
+     */
+    async changed(signal) {
+        const abort = () => { this.wake?.(); };
+        signal.addEventListener('abort', abort, { once: true });
+        try {
+            while (!this.dirty && !signal.aborted) {
+                await new Promise((resolve) => { this.wake = resolve; });
+                this.wake = undefined;
+            }
+        }
+        finally {
+            signal.removeEventListener('abort', abort);
+        }
+        this.dirty = false;
+        return !signal.aborted;
+    }
+}
+/**
+ * Registry of access policies, the Gateway's access decisions, list
+ * filtering, and the per-Peer access snapshot. Every composition that mounts
+ * the Gateway mounts this service too.
+ */
+let RemoteAccessService = (() => {
+    let _classSuper = TypertRemoteService;
+    let _instanceExtraInitializers = [];
+    let _follow_decorators;
+    return class RemoteAccessService extends _classSuper {
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            _follow_decorators = [Remote({ mode: 'stream' })];
+            __esDecorate(this, null, _follow_decorators, { kind: "method", name: "follow", static: false, private: false, access: { has: obj => "follow" in obj, get: obj => obj.follow }, metadata: _metadata }, null, _instanceExtraInitializers);
+            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        }
+        policies = (__runInitializers(this, _instanceExtraInitializers), new Map());
+        /** Policies whose failure was logged since the last `invalidate()`; their later failures stay silent. */
+        reported = new Set();
+        followers = new Set();
+        /** Aborted when this instance unloads; every open snapshot generation ends with it. */
+        lifetime = new AbortController();
+        /** @param ctx - owning Host plugin Context. */
+        constructor(ctx) {
+            super(ctx, 'remoteAccess');
+            ctx.effect(() => () => { this.lifetime.abort(); }, 'remoteAccess: snapshot generations');
+            // Every index the webServer renders belongs to the owner; snapshotFor documents non-owner pages.
+            ctx.inject(['webServer'], (webCtx) => {
+                webCtx.on('webserver/index-inject', (table) => {
+                    table.push({ kind: 'global', name: REMOTE_ACCESS_SNAPSHOT_KEY, value: OWNER_BASELINE });
+                });
+            });
+        }
+        /**
+         * Register the policy of one non-owner principal kind in the caller's
+         * fiber; open snapshots are recomputed on registration and removal.
+         * @param kind - the principal kind the policy serves; never `owner`.
+         * @param policy - business-owned bindings and refusal reasons for principals of `kind`.
+         * @returns disposer removing this policy.
+         * @throws Error when `kind` already has a policy.
+         */
+        registerPolicy(kind, policy) {
+            const policies = this.policies;
+            if (policies.has(kind))
+                throw new Error(`remote access: principal kind ${JSON.stringify(kind)} already has a policy`);
+            const entry = { kind, policy };
+            const dispose = this.ctx.effect(() => {
+                policies.set(kind, entry);
+                this.invalidate();
+                return () => {
+                    policies.delete(kind);
+                    this.invalidate();
+                };
+            }, `remoteAccess.registerPolicy(${JSON.stringify(kind)})`);
+            return () => { void dispose(); };
+        }
+        /**
+         * Report that the bindings or condition answers for `principal` may have
+         * changed. Business packages call this on every grant, revocation, mode
+         * change, and expiry; open snapshots re-push, and the next failure of each
+         * policy is logged again.
+         * @param principal - affected principal; omitted for every principal.
+         */
+        invalidate(principal) {
+            this.reported.clear();
+            const key = principal === undefined ? undefined : canonicalJson(principal);
+            for (const follower of this.followers) {
+                if (key === undefined || canonicalJson(follower.principal) === key)
+                    follower.touch();
+            }
+        }
+        /**
+         * Gateway-only: decide one request whose resources the Gateway resolved.
+         * The owner is allowed, and so is `remoteAccess/follow`: every Peer reads
+         * its own snapshot. Otherwise the action is allowed only when, on every
+         * listed resource, some binding of the principal's policy names that
+         * resource, has a role listing the action, and has no condition or a
+         * condition that allows. `bindings()` is called once per decision.
+         * @param request - the caller or recipient, the action, the resources it
+         *   touches, and a call's arguments.
+         * @returns `allow`; or `deny` with `no-allow` when the principal kind has
+         *   no policy, the first refusing condition's reason on the first resource
+         *   no binding allows, else `explain()`'s reason, else `no-allow`;
+         *   `policy-failed` when `bindings()`, a condition, or `explain()` throws,
+         *   logged once per policy until the next `invalidate()`. The Gateway
+         *   throws `remote-access/denied` for a denied call and drops a denied event.
+         */
+        decide(request) {
+            const { principal, action } = request;
+            // oxlint-disable-next-line typescript/no-unnecessary-condition -- other packages merge non-owner kinds into PrincipalMap.
+            if (principal.kind === 'owner' || action === FOLLOW_ACTION)
+                return ALLOW;
+            const entry = this.policies.get(principal.kind);
+            if (entry === undefined)
+                return NO_ALLOW;
+            const bindings = this.bindingsOf(entry, principal, action);
+            if (bindings === undefined)
+                return POLICY_FAILED;
+            for (const resource of request.resources) {
+                const evaluation = this.evaluate(entry, bindings, action, resource, request.args);
+                switch (evaluation.kind) {
+                    case 'allow':
+                        continue;
+                    case 'failed':
+                        return POLICY_FAILED;
+                    case 'refuse':
+                        return evaluation.refusal ?? this.explain(entry, request);
+                    /* v8 ignore next -- closed union. */
+                    default:
+                        return assertNever(evaluation);
+                }
+            }
+            return ALLOW;
+        }
+        /**
+         * Filter items inside a Remote method. The invocation is read from the
+         * Context that accessed this service, so call it as
+         * `this.ctx.remoteAccess.allows(resource)` from the Remote method. Each
+         * check reads the policy's bindings again, so a long-running stream sees
+         * binding changes from the next check on.
+         * @param resource - resource of one result item.
+         * @returns true for the owner and outside a Remote call; otherwise whether
+         *   the invocation's endpoint action is allowed on `resource` without call
+         *   arguments, false when the policy is absent or fails.
+         */
+        allows(resource) {
+            const invocation = this.ctx.invocation;
+            const principal = principalOf(invocation);
+            if (invocation === undefined || principal === undefined)
+                return true;
+            const action = `${invocation.request.namespace}/${invocation.request.method}`;
+            const entry = this.policies.get(principal.kind);
+            if (entry === undefined)
+                return false;
+            const bindings = this.bindingsOf(entry, principal, action);
+            return bindings !== undefined && this.evaluate(entry, bindings, action, resource, undefined).kind === 'allow';
+        }
+        /**
+         * The baseline a page opens with before its snapshot stream connects. A
+         * business package rendering a non-owner page assigns this value to
+         * {@link REMOTE_ACCESS_SNAPSHOT_KEY} after every index injection row,
+         * replacing the owner baseline the webServer index carries.
+         * @param principal - the page's caller identity.
+         * @returns the owner baseline for the owner; otherwise the principal's current grants.
+         */
+        snapshotFor(principal) {
+            // oxlint-disable-next-line typescript/no-unnecessary-condition -- other packages merge non-owner kinds into PrincipalMap.
+            if (principal.kind === 'owner')
+                return OWNER_BASELINE;
+            return { type: 'baseline', owner: false, grants: this.grantsFor(principal) };
+        }
+        /**
+         * Stream the calling Peer's access snapshot: one baseline, then `upsert`
+         * and `remove` frames after each `invalidate()` and each policy
+         * registration or removal that changes a grant. The owner receives only
+         * `{ owner: true }`. The generation ends when `signal` aborts or this
+         * service unloads, so a reloaded service starts every reader from a fresh
+         * baseline.
+         * @param signal - generation cancellation.
+         * @returns the access frames of one generation.
+         */
+        async *follow(signal) {
+            signal.throwIfAborted();
+            const generation = AbortSignal.any([signal, this.lifetime.signal]);
+            const principal = principalOf(this.ctx.invocation);
+            if (principal === undefined) {
+                yield this.snapshotFor(OWNER);
+                await abortion(generation);
+                return;
+            }
+            const follower = new AccessFollower(principal);
+            this.followers.add(follower);
+            try {
+                let sent = this.grantsFor(principal);
+                yield { type: 'baseline', owner: false, grants: sent };
+                while (await follower.changed(generation)) {
+                    const next = this.grantsFor(principal);
+                    const previous = sent;
+                    sent = next;
+                    for (const grant of next) {
+                        const before = previous.find(other => sameResource(other.resource, grant.resource));
+                        if (before === undefined || !sameActions(before.actions, grant.actions))
+                            yield { type: 'upsert', grant };
+                    }
+                    for (const grant of previous) {
+                        if (!next.some(other => sameResource(other.resource, grant.resource)))
+                            yield { type: 'remove', resource: grant.resource };
+                    }
+                }
+            }
+            finally {
+                this.followers.delete(follower);
+            }
+        }
+        /** One `bindings()` call; `undefined` after a logged failure. */
+        bindingsOf(entry, principal, purpose) {
+            try {
+                return entry.policy.bindings(principal);
+            }
+            catch (error) {
+                // A policy failure is contained to this question, so one faulty rule cannot break a shared event stream.
+                this.report(entry, `list bindings for ${purpose}`, error);
+                return undefined;
+            }
+        }
+        /** Find a binding on `resource` whose role lists `action` and whose condition, if any, allows. */
+        evaluate(entry, bindings, action, resource, args) {
+            let refusal;
+            for (const binding of bindings) {
+                if (!sameResource(binding.resource, resource) || !binding.role.actions.includes(action))
+                    continue;
+                if (binding.condition === undefined)
+                    return ALLOWED;
+                let decision;
+                try {
+                    decision = binding.condition(args === undefined ? { action, resource } : { action, resource, args });
+                }
+                catch (error) {
+                    this.report(entry, `evaluate a condition for ${action}`, error);
+                    return FAILED;
+                }
+                if (decision.kind === 'allow')
+                    return ALLOWED;
+                refusal ??= decision;
+            }
+            return { kind: 'refuse', refusal };
+        }
+        /** The refusal reason `explain()` names, else `no-allow`; `policy-failed` when it throws. */
+        explain(entry, request) {
+            let reason;
+            try {
+                reason = entry.policy.explain?.(request);
+            }
+            catch (error) {
+                this.report(entry, `explain a refusal of ${request.action}`, error);
+                return POLICY_FAILED;
+            }
+            return reason === undefined ? NO_ALLOW : { kind: 'deny', reason };
+        }
+        /**
+         * One grant per bound resource, in first-binding order: the endpoint
+         * actions of the resource's bindings that `decide()` would allow there
+         * without call arguments. A resource with no such action gets no grant;
+         * event actions stay out of the snapshot.
+         */
+        grantsFor(principal) {
+            const entry = this.policies.get(principal.kind);
+            if (entry === undefined)
+                return [];
+            const bindings = this.bindingsOf(entry, principal, 'a snapshot');
+            if (bindings === undefined)
+                return [];
+            const grants = [];
+            const seen = [];
+            for (const { resource } of bindings) {
+                if (seen.some(other => sameResource(other, resource)))
+                    continue;
+                seen.push(resource);
+                const candidates = new Set();
+                for (const binding of bindings) {
+                    if (!sameResource(binding.resource, resource))
+                        continue;
+                    for (const action of binding.role.actions) {
+                        if (!action.startsWith('event:'))
+                            candidates.add(action);
+                    }
+                }
+                const actions = [...candidates].filter(action => this.evaluate(entry, bindings, action, resource, undefined).kind === 'allow').sort();
+                if (actions.length > 0)
+                    grants.push(Object.freeze({ resource, actions: Object.freeze(actions) }));
+            }
+            return grants;
+        }
+        /** Log a policy failure once per policy until the next `invalidate()`; snapshots and lists ask many times per change. */
+        report(entry, action, error) {
+            if (this.reported.has(entry))
+                return;
+            this.reported.add(entry);
+            this.ctx.logger.warn(`remote access: the ${JSON.stringify(entry.kind)} policy failed to ${action}; its further failures are not logged until access state changes`);
+            this.ctx.logger.warn(error);
+        }
+    };
+})();
+export { RemoteAccessService };
+/* v8 ignore next 3 -- closed-union backstop. */
+function assertNever(value) {
+    throw new Error(`remote access: unreachable value ${JSON.stringify(value)}`);
+}
+/** Key-order-independent JSON text identifying one principal. */
+function canonicalJson(value) {
+    if (Array.isArray(value))
+        return `[${value.map(canonicalJson).join(',')}]`;
+    if (typeof value === 'object' && value !== null) {
+        // Own keys are unique, so no two entries compare equal.
+        const entries = Object.entries(value).sort(([left], [right]) => (left < right ? -1 : 1));
+        return `{${entries.map(([key, item]) => `${JSON.stringify(key)}:${canonicalJson(item)}`).join(',')}}`;
+    }
+    return JSON.stringify(value);
+}
+/** Resources are equal when their kinds and ids are; `global` carries no id. */
+function sameResource(left, right) {
+    return left.kind === right.kind && left.id === right.id;
+}
+function sameActions(left, right) {
+    return left.length === right.length && left.every((action, index) => action === right[index]);
+}
+function abortion(signal) {
+    return new Promise((resolve) => {
+        if (signal.aborted)
+            resolve();
+        else
+            signal.addEventListener('abort', () => { resolve(); }, { once: true });
+    });
+}
+export default RemoteAccessService;
+//# sourceMappingURL=index.js.map

package/lib/types/snapshot.d.ts

@@ -0,0 +1,8 @@
+/**
+ * The index global carrying a page's first access snapshot, shared by the
+ * Host row that writes it and the Client mount that reads it.
+ * @module @qlzt/dsh-api-remote-access/src/snapshot
+ */
+/** `globalThis` property an index injection row assigns to the page's opening baseline. */
+export declare const REMOTE_ACCESS_SNAPSHOT_KEY = "__DSH_REMOTE_ACCESS__";
+//# sourceMappingURL=snapshot.d.ts.map

package/lib/types/snapshot.js

@@ -0,0 +1,8 @@
+/**
+ * The index global carrying a page's first access snapshot, shared by the
+ * Host row that writes it and the Client mount that reads it.
+ * @module @qlzt/dsh-api-remote-access/src/snapshot
+ */
+/** `globalThis` property an index injection row assigns to the page's opening baseline. */
+export const REMOTE_ACCESS_SNAPSHOT_KEY = '__DSH_REMOTE_ACCESS__';
+//# sourceMappingURL=snapshot.js.map

package/lib/types/types.d.ts

@@ -0,0 +1,130 @@
+/**
+ * Method-level access control contracts: actions, roles, bindings, policies,
+ * decision requests, and the access snapshot stream.
+ * @module @qlzt/dsh-api-remote-access/types
+ */
+import type { Principal, RemoteAccessResource, RemoteAccessResourceKind, RemoteAccessResourceOf } from '@qlzt/dsh-typert-protocol';
+export type { RemoteAccessResource, RemoteAccessResourceKind, RemoteAccessResourceOf, TypertResourceKind, TypertResourceMap, } from '@qlzt/dsh-typert-protocol';
+/** Canonical `<namespace>/<method>` Remote endpoint; its segments never contain `:`. */
+export type RemoteAccessEndpoint = `${string}/${string}`;
+/** A Remote endpoint, or `event:<name>` for one forwarded event. */
+export type RemoteAccessAction = RemoteAccessEndpoint | `event:${string}`;
+/** A named action set over one resource kind; a plain value the business package owns. */
+export interface RemoteAccessRole<K extends RemoteAccessResourceKind> {
+    /** Name for diagnostics; decisions read only `resource` and `actions`. */
+    readonly name: string;
+    /** The resource kind every binding of this role names. */
+    readonly resource: K;
+    /** Actions the role allows on its binding's resource. */
+    readonly actions: readonly RemoteAccessAction[];
+}
+/** Answer of `decide()` and of a condition. */
+export type RemoteAccessDecision = {
+    readonly kind: 'allow';
+} | {
+    readonly kind: 'deny';
+    readonly reason: string;
+};
+/**
+ * Refines one binding for one action on its resource. Called synchronously,
+ * only for a binding whose resource matches and whose role lists the action.
+ * @param request - the action, the binding's resource, and the named
+ *   arguments of a concrete call, validated against their Typert-compiled
+ *   types with lookup parameters as wire identities; `args` is absent for
+ *   events, snapshots, and list filtering, where the condition answers for
+ *   the action alone.
+ * @returns allow, or deny with the reason a refused call reports.
+ */
+export type RemoteAccessCondition<K extends RemoteAccessResourceKind> = (request: {
+    readonly action: RemoteAccessAction;
+    readonly resource: RemoteAccessResourceOf<K>;
+    readonly args?: Readonly<Record<string, unknown>>;
+}) => RemoteAccessDecision;
+/** One role on one resource of the role's kind; the resource type follows from the role. */
+export type RemoteAccessBinding = {
+    [K in RemoteAccessResourceKind]: {
+        readonly role: RemoteAccessRole<K>;
+        readonly resource: RemoteAccessResourceOf<K>;
+        /** Without a condition, the binding allows every action its role lists. */
+        readonly condition?: RemoteAccessCondition<K>;
+    };
+}[RemoteAccessResourceKind];
+/** One access question: may `principal` take `action` on `resources`. */
+export interface RemoteAccessRequest<P extends Principal> {
+    readonly principal: P;
+    readonly action: RemoteAccessAction;
+    /**
+     * Every resource the action touches, the global resource alone when it
+     * names none; allowed only when the action is allowed on every listed resource.
+     */
+    readonly resources: readonly RemoteAccessResource[];
+    /**
+     * Named arguments of a concrete call, validated against their Typert-compiled types
+     * with lookup parameters as wire identities; absent for events, snapshots, and list filtering.
+     */
+    readonly args?: Readonly<Record<string, unknown>>;
+}
+/**
+ * Business rules for one non-owner principal kind. Every member answers
+ * synchronously from state the business package holds in memory.
+ */
+export interface RemoteAccessPolicy<P extends Principal> {
+    /**
+     * List the principal's bindings. Called once per `decide()`, once per
+     * `allows()`, and once per snapshot computation; never cached.
+     * @param principal - non-owner caller of this policy's kind.
+     * @returns every binding the principal holds now.
+     */
+    bindings(principal: P): readonly RemoteAccessBinding[];
+    /**
+     * Name the reason for a request no binding allows; called only after the
+     * decision is already a deny, so it never changes the decision.
+     * @param request - the refused request.
+     * @returns the reason a refused call reports, or `undefined` for `no-allow`.
+     */
+    explain?(request: RemoteAccessRequest<P>): string | undefined;
+}
+/** Details of a refused non-owner call. */
+export interface RemoteAccessDeniedDetails {
+    /** Canonical `<namespace>/<method>` endpoint of the refused call. */
+    readonly action: string;
+    /**
+     * A condition's or `explain()`'s reason, `no-allow`, or `policy-failed`;
+     * the Gateway refuses a call whose resources are invalid with
+     * `resource-invalid` before `decide()` is asked.
+     */
+    readonly reason: string;
+}
+declare module '@qlzt/dsh-typert-protocol' {
+    interface RemoteErrorDetailsMap {
+        'remote-access/denied': RemoteAccessDeniedDetails;
+    }
+}
+/** The endpoint actions one principal may call on one resource. */
+export interface RemoteAccessGrant {
+    readonly resource: RemoteAccessResource;
+    /**
+     * Endpoint actions allowed on this resource without call arguments, sorted;
+     * plain strings because Typert generates no codec for template literal types.
+     */
+    readonly actions: readonly string[];
+}
+/**
+ * One frame of `remoteAccess/follow`. A generation opens with one baseline;
+ * an owner baseline is the only frame of its generation.
+ */
+export type RemoteAccessFrame = {
+    readonly type: 'baseline';
+    readonly owner: true;
+} | {
+    readonly type: 'baseline';
+    readonly owner: false;
+    readonly grants: readonly RemoteAccessGrant[];
+} | {
+    readonly type: 'upsert';
+    readonly grant: RemoteAccessGrant;
+} | {
+    readonly type: 'remove';
+    readonly resource: RemoteAccessResource;
+};
+//# sourceMappingURL=types.d.ts.map

package/lib/types/types.js

@@ -0,0 +1,7 @@
+/**
+ * Method-level access control contracts: actions, roles, bindings, policies,
+ * decision requests, and the access snapshot stream.
+ * @module @qlzt/dsh-api-remote-access/types
+ */
+export {};
+//# sourceMappingURL=types.js.map

package/package.json

@@ -1,6 +1,83 @@
 {
   "name": "@qlzt/dsh-api-remote-access",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "description": "Method-level Remote access control for non-owner Peers and the per-Peer access snapshot",
+  "version": "0.2.1-rc.2",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://gitee.com/zsping1989/deepseek-harness.git",
+    "directory": "packages/api/remote-access"
+  },
+  "type": "module",
+  "main": "lib/index.js",
+  "types": "lib/types/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./lib/types/index.d.ts",
+      "default": "./lib/index.js"
+    },
+    "./types": {
+      "types": "./lib/types/types.d.ts",
+      "default": "./lib/types/types.js"
+    },
+    "./client": {
+      "types": "./lib/types/client/index.d.ts",
+      "default": "./lib/client.js"
+    },
+    "./typert": {
+      "types": "./lib/typert.host.d.ts",
+      "default": "./lib/typert.host.js"
+    },
+    "./remote": {
+      "types": "./lib/typert.remote-client.d.ts",
+      "default": "./lib/typert.remote-client.js"
+    },
+    "./src/*": "./src/*",
+    "./package.json": "./package.json"
+  },
+  "dsh": {
+    "client": {
+      "external": [
+        "@qlzt/dsh-api-gateway/client"
+      ],
+      "inject": [
+        "@qlzt/dsh-api-gateway",
+        "@qlzt/dsh-client-ui-renderer"
+      ],
+      "platform": "web"
+    }
+  },
+  "files": [
+    "lib/index.js",
+    "lib/client.js",
+    "lib/types/**/*.js",
+    "lib/types/**/*.d.ts",
+    "lib/typert.host.js",
+    "lib/typert.host.d.ts",
+    "lib/typert.remote-client.js",
+    "lib/typert.remote-client.d.ts"
+  ],
+  "license": "MIT",
+  "dependencies": {
+    "@qlzt/dsh-typert-protocol": "0.2.1-rc.2",
+    "zod": "4.4.3"
+  },
+  "peerDependencies": {
+    "@deepseek-ai/cordis": "~4.0.5"
+  },
+  "devDependencies": {
+    "@deepseek-ai/cordis": "~4.0.5",
+    "@deepseek-ai/dsh-api-gateway": "0.2.1-rc.2",
+    "@deepseek-ai/dsh-client-connection": "0.2.1-rc.2",
+    "@deepseek-ai/dsh-client-ui-renderer": "0.2.1-rc.2",
+    "@deepseek-ai/dsh-client-ui-slots": "0.2.1-rc.2",
+    "@deepseek-ai/dsh-host-webserver": "0.2.1-rc.2",
+    "@deepseek-ai/dsh-typert-registry": "0.2.1-rc.2"
+  },
+  "scripts": {
+    "bundle": "tsdown",
+    "watch": "tsdown --watch"
+  }
+}