@tbox.cn/app-contracts-mall 0.1.1 → 0.9.0

package/tests/mall-control-plane.test.ts

@@ -0,0 +1,86 @@
+/**
+ * mallControlPlaneOf 投影单测（integrations v4）：
+ * root instances 注册表 → MallDeploymentControlPlane。
+ * 覆盖：无表 → 空平面 / 全字段投影 / attributes strict 拒拼错键（报允许键）/
+ * defaultInstanceId 解析（显式 / 单实例唯一解 / 多实例无默认 → undefined）/ 无表 + 独立默认。
+ */
+import { describe, expect, it } from 'vitest';
+import { mallControlPlaneOf } from '../src/server/mall-control-plane';
+import type { IntegrationsConfig } from '@tbox.cn/app-contracts';
+
+function config(overrides: Partial<IntegrationsConfig> = {}): IntegrationsConfig {
+  return { services: {}, ...overrides };
+}
+
+describe('mallControlPlaneOf：参考表投影', () => {
+  it('无参考表 → 空平面（模板装配零拓扑分支）', () => {
+    const cp = mallControlPlaneOf(config());
+    expect(cp.malls).toEqual([]);
+    expect(cp.defaultMallId).toBeUndefined();
+  });
+
+  it('双实例全字段投影（miniAppId/contactPhone/location）', () => {
+    const cp = mallControlPlaneOf(config({
+      instances: [
+        { id: 'mall-20001', name: '示例广场' },
+        {
+          id: 'mall-20002',
+          name: '另一广场',
+          attributes: {
+            miniAppId: '2021002188612345',
+            contactPhone: '0571-88888888',
+            location: { lat: 30.274, lon: 120.155, address: '杭州市西湖区' },
+          },
+        },
+      ],
+      defaultInstanceId: 'mall-20001',
+    }));
+    expect(cp.malls.length).toBe(2);
+    expect(cp.malls[0]).toEqual({ mallId: 'mall-20001', name: '示例广场' });
+    expect(cp.malls[1]).toEqual({
+      mallId: 'mall-20002',
+      name: '另一广场',
+      miniAppId: '2021002188612345',
+      contactPhone: '0571-88888888',
+      location: { lat: 30.274, lon: 120.155, address: '杭州市西湖区' },
+    });
+    expect(cp.defaultMallId).toBe('mall-20001');
+  });
+
+  it('attributes 拼错键 fail-fast（strict——错误消息含允许键清单）', () => {
+    expect(() =>
+      mallControlPlaneOf(config({
+        instances: [{ id: 'mall-20001', name: 'x', attributes: { miniAppid: 'typo' } }],
+      })),
+    ).toThrow(/miniAppId|contactPhone|location/);
+  });
+
+  it('defaultMallId：单实例免填唯一解', () => {
+    const cp = mallControlPlaneOf(config({ instances: [{ id: 'mall-20001', name: 'x' }] }));
+    expect(cp.defaultMallId).toBe('mall-20001');
+  });
+
+  it('defaultMallId：多实例无显式默认 → undefined（doctor warning 位）', () => {
+    const cp = mallControlPlaneOf(config({
+      instances: [
+        { id: 'mall-20001', name: 'a' },
+        { id: 'mall-20002', name: 'b' },
+      ],
+    }));
+    expect(cp.defaultMallId).toBeUndefined();
+  });
+
+  it('defaultMallId：无表 + defaultInstanceId 独立在场（env 注入动态默认形态）', () => {
+    const cp = mallControlPlaneOf(config({ defaultInstanceId: '42020300520' }));
+    expect(cp.malls).toEqual([]);
+    expect(cp.defaultMallId).toBe('42020300520');
+  });
+
+  it('defaultMallId：显式 null → undefined', () => {
+    const cp = mallControlPlaneOf(config({
+      instances: [{ id: 'mall-20001', name: 'x' }],
+      defaultInstanceId: null,
+    }));
+    expect(cp.defaultMallId).toBeUndefined();
+  });
+});

package/tests/member-status.test.ts

@@ -0,0 +1,197 @@
+/**
+ * 会员状态折叠单源锁（F6）：classifyMemberOutcome 双轴优先级矩阵 +
+ * externalMemberRefOf 引用取值 + runtime 出口接线。
+ */
+import { describe, expect, it } from 'vitest';
+import { classifyMemberOutcome, externalMemberRefOf, memberGateCardOf } from '../src/services/member';
+import type { MemberAccountSnapshot, MemberStatusResolution } from '../src/services/member';
+import { resolveMemberGate } from '../src/services/member';
+import * as runtime from '../src/runtime';
+
+const anonymous = { source: 'anonymous' as const };
+const dev = { source: 'dev' as const };
+
+function account(authState: 'authenticated' | 'unauthenticated', state: MemberAccountSnapshot['state']): MemberAccountSnapshot {
+  return { authState, state, observedAt: '2026-08-30T00:00:00.000Z' };
+}
+
+describe('classifyMemberOutcome（双轴折叠单源）', () => {
+  it('平台匿名优先于账户态（轴优先级锁：不触 provider 语义）', () => {
+    expect(classifyMemberOutcome(anonymous, account('authenticated', 'active'))).toBe('unauthenticated');
+  });
+
+  it('匿名 × 无 account', () => {
+    expect(classifyMemberOutcome(anonymous, undefined)).toBe('unauthenticated');
+  });
+
+  it('非匿名 × 无 account → unknown（不可臆测为未入会）', () => {
+    expect(classifyMemberOutcome(dev, undefined)).toBe('unknown');
+    expect(classifyMemberOutcome(dev, null)).toBe('unknown');
+  });
+
+  it('非匿名 × 凭证轴未认证 → unauthenticated（独立于资格轴）', () => {
+    expect(classifyMemberOutcome(dev, account('unauthenticated', 'unknown'))).toBe('unauthenticated');
+  });
+
+  it('非匿名 × 四资格态直通', () => {
+    expect(classifyMemberOutcome(dev, account('authenticated', 'unknown'))).toBe('unknown');
+    expect(classifyMemberOutcome(dev, account('authenticated', 'active'))).toBe('active');
+    expect(classifyMemberOutcome(dev, account('authenticated', 'not_enrolled'))).toBe('not_enrolled');
+    expect(classifyMemberOutcome(dev, account('authenticated', 'closed'))).toBe('closed');
+  });
+
+  it('identity 缺席 × active → active（调用方已保证在场的形态）', () => {
+    expect(classifyMemberOutcome(undefined, account('authenticated', 'active'))).toBe('active');
+  });
+});
+
+describe('externalMemberRefOf（厂商侧会员标识取值）', () => {
+  it('真实卡号优先于 opaque 引用', () => {
+    expect(externalMemberRefOf({ ...account('authenticated', 'active'), primaryMallCardNo: 'C-1001', memberRef: 'member:C-1001' })).toBe('C-1001');
+  });
+
+  it('仅 opaque 引用时兜底透传（演示链形态）', () => {
+    expect(externalMemberRefOf({ ...account('authenticated', 'active'), memberRef: 'demo:member:demo-user' })).toBe('demo:member:demo-user');
+  });
+
+  it('双缺 → undefined（调用方按软失败处理）', () => {
+    expect(externalMemberRefOf(account('authenticated', 'active'))).toBeUndefined();
+  });
+});
+
+describe('runtime 出口接线（跨模块值导入必经此处）', () => {
+  it('classifyMemberOutcome / externalMemberRefOf 经 runtime 出口可达', () => {
+    expect(runtime.classifyMemberOutcome).toBeTypeOf('function');
+    expect(runtime.externalMemberRefOf).toBeTypeOf('function');
+  });
+
+  it('memberGateCardOf / resolveMemberGate 经 runtime 出口可达（不策展 = 运行时 undefined）', () => {
+    expect(runtime.memberGateCardOf).toBeTypeOf('function');
+    expect(runtime.resolveMemberGate).toBeTypeOf('function');
+  });
+});
+
+describe('memberGateCardOf（纯卡映射）', () => {
+  const enroll = { outcome: 'not_enrolled' as const, enrollUrl: 'alipays://enroll', loginUrl: 'alipays://login' };
+  const closed = { outcome: 'closed' as const, enrollUrl: 'alipays://enroll', loginUrl: 'alipays://login' };
+  const unauth = { outcome: 'unauthenticated' as const, enrollUrl: 'alipays://enroll', loginUrl: 'alipays://login' };
+
+  it('not_enrolled + enrollUrl → member-enrollment-cta，enroll 卡全字段', () => {
+    const card = memberGateCardOf('u-1', enroll);
+    expect(card).toBeDefined();
+    expect(card!.cardType).toBe('member-enrollment-cta');
+    expect(card!.data.userId).toBe('u-1');
+    expect(card!.data.authState).toBe('authenticated');
+    expect(card!.data.state).toBe('not_enrolled');
+    expect(card!.data.enrollUrl).toBe('alipays://enroll');
+    expect(card!.note).toBe('未入会 · 点击卡片完成入会');
+  });
+
+  it('closed + enrollUrl → member-enrollment-cta，state=closed 且 title 与 not_enrolled 一致（文案统一）', () => {
+    const card = memberGateCardOf('u-1', closed);
+    const enrolled = memberGateCardOf('u-1', enroll);
+    expect(card).toBeDefined();
+    expect(card!.data.state).toBe('closed');
+    expect(card!.data.title).toBe(enrolled!.data.title);
+  });
+
+  it('unauthenticated + loginUrl → member-login-cta，login 卡无 userId', () => {
+    const card = memberGateCardOf('u-1', unauth);
+    expect(card).toBeDefined();
+    expect(card!.cardType).toBe('member-login-cta');
+    expect(card!.data.loginUrl).toBe('alipays://login');
+    expect(card!.data.userId).toBeUndefined();
+    expect(card!.note).toBe('未登录 · 点击卡片登录');
+  });
+
+  it('未配深链 → 恒出卡（无 URL 字段；深链为可选透传素材）', () => {
+    const enrollCard = memberGateCardOf('u-1', { outcome: 'not_enrolled' });
+    expect(enrollCard).toBeDefined();
+    expect(enrollCard!.cardType).toBe('member-enrollment-cta');
+    expect(enrollCard!.data.enrollUrl).toBeUndefined();
+    expect(enrollCard!.data.userId).toBe('u-1');
+    const loginCard = memberGateCardOf('u-1', { outcome: 'unauthenticated' });
+    expect(loginCard).toBeDefined();
+    expect(loginCard!.cardType).toBe('member-login-cta');
+    expect(loginCard!.data.loginUrl).toBeUndefined();
+  });
+
+  it('空串/空白串深链归一为无 URL 卡（trim 归一，等价缺省）', () => {
+    const enrollCard = memberGateCardOf('u-1', { outcome: 'not_enrolled', enrollUrl: '' });
+    expect(enrollCard).toBeDefined();
+    expect(enrollCard!.data.enrollUrl).toBeUndefined();
+    const loginCard = memberGateCardOf('u-1', { outcome: 'unauthenticated', loginUrl: '   ' });
+    expect(loginCard).toBeDefined();
+    expect(loginCard!.data.loginUrl).toBeUndefined();
+  });
+
+  it('带 URL 时 enroll 卡全字段回归（userId/authState/state/title/enrollUrl 齐全）', () => {
+    const card = memberGateCardOf('u-1', enroll);
+    expect(card!.data).toMatchObject({
+      userId: 'u-1',
+      authState: 'authenticated',
+      state: 'not_enrolled',
+      title: '入会后继续',
+      enrollUrl: 'alipays://enroll',
+    });
+  });
+
+  it('active / unknown / unavailable → undefined（软放行态不产卡）', () => {
+    expect(memberGateCardOf('u-1', { outcome: 'active' })).toBeUndefined();
+    expect(memberGateCardOf('u-1', { outcome: 'unknown' })).toBeUndefined();
+    expect(memberGateCardOf('u-1', { outcome: 'unavailable' })).toBeUndefined();
+  });
+
+  it('空 userId + not_enrolled → undefined', () => {
+    expect(memberGateCardOf('', enroll)).toBeUndefined();
+  });
+});
+
+describe('resolveMemberGate（编排单源）', () => {
+  const reqCtx = { identity: { userId: 'u-1', source: 'dev' as const } } as never;
+  const statusOf = (s: Partial<MemberStatusResolution>): MemberStatusResolution =>
+    ({ outcome: 'active', ...s }) as MemberStatusResolution;
+
+  it('工厂缺席 → 放行（fail-open）', async () => {
+    await expect(resolveMemberGate(undefined, reqCtx)).resolves.toBeUndefined();
+  });
+
+  it('工厂抛错 → 放行（fail-open 兜底）', async () => {
+    const factory = async () => { throw new Error('boom'); };
+    await expect(resolveMemberGate(factory, reqCtx)).resolves.toBeUndefined();
+  });
+
+  it('软放行：active / unknown / unavailable', async () => {
+    for (const outcome of ['active', 'unknown', 'unavailable'] as const) {
+      await expect(resolveMemberGate(async () => statusOf({ outcome }), reqCtx)).resolves.toBeUndefined();
+    }
+  });
+
+  it('硬门禁：unauthenticated + loginUrl → login 卡', async () => {
+    const gate = await resolveMemberGate(
+      async () => statusOf({ outcome: 'unauthenticated', loginUrl: 'alipays://login' }),
+      reqCtx,
+    );
+    expect(gate).toBeDefined();
+    expect(gate!.card?.cardType).toBe('member-login-cta');
+    expect(gate!.notice).toBe('请先登录后再使用该服务');
+  });
+
+  it('硬门禁：not_enrolled + enrollUrl → enrollment 卡', async () => {
+    const gate = await resolveMemberGate(
+      async () => statusOf({ outcome: 'not_enrolled', enrollUrl: 'alipays://enroll' }),
+      reqCtx,
+    );
+    expect(gate).toBeDefined();
+    expect(gate!.card?.cardType).toBe('member-enrollment-cta');
+    expect(gate!.notice).toBe('完成入会后即可使用该服务');
+  });
+
+  it('硬门禁未配深链 → 恒出卡（无 URL 字段），notice 保留', async () => {
+    const gate = await resolveMemberGate(async () => statusOf({ outcome: 'closed' }), reqCtx);
+    expect(gate).toBeDefined();
+    expect(gate!.card?.cardType).toBe('member-enrollment-cta');
+    expect(gate!.card?.data.enrollUrl).toBeUndefined();
+    expect(gate!.notice).toBe('重新入会后可恢复使用该服务');
+  });
+});

package/tests/query-context.test.ts

@@ -0,0 +1,111 @@
+/**
+ * query-context 组装单源单测（0.8.0 消费层统一化）：
+ * withMallScopeFromQuery 写入口契约（Q1-Q6）+ 消费原子/组合子（Q7-Q9）。
+ * Q6 = plazaId 契约锁：helper 只认 mallId，别名归一属客户端 mall-scope-url 单点职责。
+ */
+import { describe, expect, it } from 'vitest';
+import type { RequestContext } from '@tbox.cn/app-contracts';
+
+import {
+  mallScopeOrEmpty,
+  mallSubjectIdOf,
+  toMallQueryContext,
+  withMallScopeFromQuery,
+} from '../src/query-context';
+import { parseMallScope } from '../src/scope';
+
+function reqCtxOf(overrides: Partial<RequestContext> = {}): RequestContext {
+  return {
+    identity: { userId: 'u-1', source: 'external' },
+    credentials: { provider: 'mock', token: 't', attributes: {} },
+    attributes: {},
+    ...overrides,
+  };
+}
+
+describe('withMallScopeFromQuery（GET query 注入唯一写入口）', () => {
+  it('Q1: mallId+miniAppId 双全 → 注入且 parseMallScope 往返等价', () => {
+    const base = reqCtxOf();
+    const result = withMallScopeFromQuery(base, { mallId: ' m1 ', miniAppId: 'app1' });
+    expect(result).not.toBe(base);
+    expect(parseMallScope(result.attributes)).toEqual({ mallId: 'm1', miniAppId: 'app1' });
+  });
+
+  it('Q2: mallId 缺/空串/纯空白/非 string → 原样返回（不注入）', () => {
+    const base = reqCtxOf();
+    for (const query of [{}, { mallId: '' }, { mallId: '   ' }, { mallId: ['a', 'b'] }, { mallId: 42 }]) {
+      expect(withMallScopeFromQuery(base, query as Record<string, unknown>)).toBe(base);
+    }
+  });
+
+  it('Q3: query miniAppId 缺 + opts.miniAppId → 注入 opts 值', () => {
+    const result = withMallScopeFromQuery(reqCtxOf(), { mallId: 'm1' }, { miniAppId: 'from-opts' });
+    expect(parseMallScope(result.attributes)).toEqual({ mallId: 'm1', miniAppId: 'from-opts' });
+  });
+
+  it('Q4: mallId 在而 miniAppId 双缺（query 空 + 无 opts）→ 注入 mallId-only（v4：miniAppId 可选）', () => {
+    const base = reqCtxOf();
+    expect(parseMallScope(withMallScopeFromQuery(base, { mallId: 'm1' }).attributes)).toEqual({
+      mallId: 'm1',
+    });
+    expect(parseMallScope(withMallScopeFromQuery(base, { mallId: 'm1' }, {}).attributes)).toEqual({
+      mallId: 'm1',
+    });
+    // miniAppId 显式空串（trim 后空）双缺等价 → 仍 mallId-only
+    expect(
+      parseMallScope(withMallScopeFromQuery(base, { mallId: 'm1', miniAppId: '' }, { miniAppId: '  ' }).attributes),
+    ).toEqual({ mallId: 'm1' });
+  });
+
+  it('Q5: query miniAppId 优先于 opts（透传真源优先）', () => {
+    const result = withMallScopeFromQuery(
+      reqCtxOf(),
+      { mallId: 'm1', miniAppId: 'from-query' },
+      { miniAppId: 'from-opts' },
+    );
+    expect(parseMallScope(result.attributes)?.miniAppId).toBe('from-query');
+  });
+
+  it('Q6: 仅 plazaId（客户端别名）→ 不注入（契约锁：helper 零别名感知）', () => {
+    const base = reqCtxOf();
+    expect(withMallScopeFromQuery(base, { plazaId: 'p1' })).toBe(base);
+  });
+
+  it('Q5b: 覆盖既有 attributes.mall（与既有 spread 覆盖语义一致）', () => {
+    const base = reqCtxOf({ attributes: { mall: { mallId: 'old', miniAppId: 'old-app' } } });
+    const result = withMallScopeFromQuery(base, { mallId: 'new', miniAppId: 'new-app' });
+    expect(parseMallScope(result.attributes)).toEqual({ mallId: 'new', miniAppId: 'new-app' });
+  });
+});
+
+describe('消费原子与组合子', () => {
+  it('Q7: mallScopeOrEmpty——有 scope 原样透传；无 scope 空兜底新对象', () => {
+    const scoped = reqCtxOf({ attributes: { mall: { mallId: 'm1', miniAppId: 'a1' } } });
+    expect(mallScopeOrEmpty(scoped)).toEqual({ mallId: 'm1', miniAppId: 'a1' });
+    const bare = reqCtxOf();
+    const fallback = mallScopeOrEmpty(bare);
+    expect(fallback).toEqual({ miniAppId: '', mallId: '' });
+    expect(mallScopeOrEmpty(bare)).not.toBe(fallback); // 免疫共享引用
+  });
+
+  it('Q8: mallSubjectIdOf——anonymous → undefined；local/external/dev → userId', () => {
+    for (const source of ['local', 'external', 'dev'] as const) {
+      expect(mallSubjectIdOf(reqCtxOf({ identity: { userId: 'u-1', source } }))).toBe('u-1');
+    }
+    expect(mallSubjectIdOf(reqCtxOf({ identity: { userId: 'u-1', source: 'anonymous' } }))).toBeUndefined();
+  });
+
+  it('Q9: toMallQueryContext = mallScopeOrEmpty ∪ mallSubjectIdOf 的组合', () => {
+    const scoped = reqCtxOf({ attributes: { mall: { mallId: 'm1', miniAppId: 'a1' } } });
+    expect(toMallQueryContext(scoped)).toEqual({
+      scope: { mallId: 'm1', miniAppId: 'a1' },
+      subjectId: 'u-1',
+      requestContext: scoped,
+    });
+    const bare = reqCtxOf({ identity: { userId: 'u-1', source: 'anonymous' } });
+    expect(toMallQueryContext(bare)).toEqual({
+      scope: { miniAppId: '', mallId: '' },
+      requestContext: bare,
+    });
+  });
+});

package/tests/request-credentials.test.ts

@@ -0,0 +1,38 @@
+/**
+ * 请求凭证访问器通道锁（F5 单源）：credentialsOpenId 必须读
+ * ExternalCredentials.attributes.openid（identity.ts 契约唯一通道）——
+ * 曾误读顶层 credentials.openid（契约无此键，恒 undefined），
+ * 致身份绑定 OpenId 恒空；本文件防止回退到顶层读取。
+ */
+import { describe, expect, it } from 'vitest';
+import type { RequestContext } from '@tbox.cn/app-contracts';
+import { credentialsOpenId, credentialsMemberId, credentialsToken } from '../src/server/request-credentials';
+
+const ctx = (credentials: unknown) => ({ credentials }) as never as RequestContext;
+
+describe('request-credentials 凭证访问器', () => {
+  it('openid 从 attributes 通道提取（外部身份三元组）', () => {
+    const result = credentialsOpenId(ctx({
+      provider: 'mall-gateway',
+      token: 't_1',
+      attributes: { openid: 'o_abc', lightuid: 'l_1', signid: 's_1' },
+    }));
+    expect(result).toBe('o_abc');
+  });
+
+  it('顶层 openid 键不读取（契约无此键——缺陷形态回归锁）', () => {
+    const result = credentialsOpenId(ctx({ provider: 'x', token: 't', openid: 'top-level-o' }));
+    expect(result).toBe('');
+  });
+
+  it('attributes 缺失 / 非字符串值 → 空串不抛', () => {
+    expect(credentialsOpenId(ctx({ provider: 'x', token: 't' }))).toBe('');
+    expect(credentialsOpenId(ctx({ provider: 'x', token: 't', attributes: { openid: 123 } }))).toBe('');
+    expect(credentialsOpenId(ctx(undefined))).toBe('');
+  });
+
+  it('token 顶层键 / memberId attributes 通道（对照基准）', () => {
+    expect(credentialsToken(ctx({ provider: 'x', token: 'tok' }))).toBe('tok');
+    expect(credentialsMemberId(ctx({ provider: 'x', token: 't', attributes: { memberId: 'm_1' } }))).toBe('m_1');
+  });
+});

package/tests/resolve-primitives.test.ts

@@ -0,0 +1,55 @@
+/**
+ * 解析原语单测（017 槽位原子化）：
+ * - mallScopeOf：模块 ports resolveService 入参 scope 形状钉死（{mallId}|{}，不含 miniAppId）
+ * - isExpectedProviderAbsence：兜底矩阵唯一谓词（三码 true；NOT_IMPLEMENTED 等其余 false）
+ */
+import { describe, expect, it } from 'vitest';
+import { mallScopeOf, parseMallScope } from '../src/scope';
+import { isExpectedProviderAbsence } from '@tbox.cn/app-contracts';
+
+describe('mallScopeOf（F10 行为钉死）', () => {
+  it('mall scope 在场 → { mallId }（flat，不含 miniAppId/subjectId）', () => {
+    const scope = mallScopeOf({
+      attributes: { mall: { mallId: 'm1', miniAppId: 'app1', subjectId: 's1' } },
+    });
+    expect(scope).toEqual({ mallId: 'm1' });
+  });
+
+  it('attributes 空对象 → {}（与四模块 ports 旧直连行为逐字等价）', () => {
+    expect(mallScopeOf({ attributes: {} })).toEqual({});
+  });
+
+  it('attributes undefined → {}', () => {
+    expect(mallScopeOf({})).toEqual({});
+  });
+
+  it('mall 键在场但形状非法 → {}（zod fail-soft）', () => {
+    expect(mallScopeOf({ attributes: { mall: { mallId: '' } } })).toEqual({});
+    expect(mallScopeOf({ attributes: { mall: 'oops' } })).toEqual({});
+  });
+
+  it('与 parseMallScope 派生关系一致（单源薄包装）', () => {
+    const attrs = { mall: { mallId: 'm2' } };
+    expect(mallScopeOf({ attributes: attrs })).toEqual(
+      parseMallScope(attrs)?.mallId ? { mallId: parseMallScope(attrs)!.mallId } : {},
+    );
+  });
+});
+
+describe('isExpectedProviderAbsence（兜底矩阵谓词）', () => {
+  const errOf = (code: string) => Object.assign(new Error('x'), { code });
+
+  it('三缺席码 → true（槽未配置/实例缺失/实例禁用）', () => {
+    expect(isExpectedProviderAbsence(errOf('PROVIDER_SERVICE_NOT_CONFIGURED'))).toBe(true);
+    expect(isExpectedProviderAbsence(errOf('PROVIDER_INSTANCE_NOT_FOUND'))).toBe(true);
+    expect(isExpectedProviderAbsence(errOf('PROVIDER_INSTANCE_DISABLED'))).toBe(true);
+  });
+
+  it('NOT_IMPLEMENTED / BINDING_UNRESOLVED / 普通错误 → false（上抛）', () => {
+    expect(isExpectedProviderAbsence(errOf('PROVIDER_NOT_IMPLEMENTED'))).toBe(false);
+    expect(isExpectedProviderAbsence(errOf('PROVIDER_BINDING_UNRESOLVED'))).toBe(false);
+    expect(isExpectedProviderAbsence(new Error('boom'))).toBe(false);
+    expect(isExpectedProviderAbsence(undefined)).toBe(false);
+    expect(isExpectedProviderAbsence(null)).toBe(false);
+  });
+});

package/tests/service-slots.test.ts

@@ -0,0 +1,78 @@
+/**
+ * service slot 词汇交叉锁（017 槽位原子化）：
+ * 共址 TS 常量并集 ≡ service-slots.json slots（逐元素相等，含计数）。
+ * JSON 是 guard（scripts/guard-service-slots.mjs）的真源；常量是 TS 消费方的带锁视图。
+ */
+import { describe, expect, it } from 'vitest';
+import slotsJson from '../src/service-slots.json';
+import {
+  MEMBER_ACCOUNT_SERVICE,
+  MEMBER_PROFILE_SERVICE,
+  MEMBER_CARD_SERVICE,
+  MEMBER_BENEFITS_SERVICE,
+  MEMBER_ENROLLMENT_SERVICE,
+} from '../src/services/member';
+import {
+  PARKING_QUERY_SERVICE,
+  PARKING_PAYMENT_SERVICE,
+  PARKING_VEHICLE_SERVICE,
+} from '../src/services/parking';
+import {
+  PROMOTION_OFFERS_SERVICE,
+  PROMOTION_ENTITLEMENTS_SERVICE,
+  PROMOTION_ACTIVITIES_SERVICE,
+  PROMOTION_ACQUISITION_SERVICE,
+} from '../src/services/promotion';
+import {
+  SHOPPING_CATALOG_SERVICE,
+  SHOPPING_SHOPS_SERVICE,
+  SHOPPING_CATEGORIES_SERVICE,
+  SHOPPING_DIRECTORY_SERVICE,
+} from '../src/services/shopping-guide';
+import { MALL_INFO_SERVICE } from '../src/services/mall-info';
+import { AUTH_LOGIN_SERVICE } from '../src/assembly';
+
+const constants = [
+  MEMBER_ACCOUNT_SERVICE,
+  MEMBER_PROFILE_SERVICE,
+  MEMBER_CARD_SERVICE,
+  MEMBER_BENEFITS_SERVICE,
+  MEMBER_ENROLLMENT_SERVICE,
+  PARKING_QUERY_SERVICE,
+  PARKING_PAYMENT_SERVICE,
+  PARKING_VEHICLE_SERVICE,
+  PROMOTION_OFFERS_SERVICE,
+  PROMOTION_ENTITLEMENTS_SERVICE,
+  PROMOTION_ACTIVITIES_SERVICE,
+  PROMOTION_ACQUISITION_SERVICE,
+  SHOPPING_CATALOG_SERVICE,
+  SHOPPING_SHOPS_SERVICE,
+  SHOPPING_CATEGORIES_SERVICE,
+  SHOPPING_DIRECTORY_SERVICE,
+  AUTH_LOGIN_SERVICE,
+  MALL_INFO_SERVICE,
+];
+
+describe('service slot 词汇交叉锁（JSON 真源 ↔ TS 共址常量）', () => {
+  it('计数 = 18（auth.alipay-login 与 mall.info 含在内）', () => {
+    expect(slotsJson.slots).toHaveLength(18);
+    expect(constants).toHaveLength(18);
+  });
+
+  it('常量并集 ≡ JSON slots（互为子集；无重复无缺漏）', () => {
+    const jsonSet = new Set(slotsJson.slots);
+    const constSet = new Set(constants);
+    expect(jsonSet.size).toBe(18);
+    expect(constSet.size).toBe(18);
+    for (const id of jsonSet) expect(constSet.has(id), `常量缺 ${id}`).toBe(true);
+    for (const id of constSet) expect(jsonSet.has(id), `JSON 缺 ${id}`).toBe(true);
+  });
+
+  it('词汇形状：domain.capability 且 domain ∈ 五域 + auth', () => {
+    const domains = new Set(['member', 'parking', 'promotion', 'shopping-guide', 'auth', 'mall']);
+    for (const id of slotsJson.slots) {
+      expect(id).toMatch(/^[a-z-]+\.[a-z-]+$/);
+      expect(domains.has(id.split('.')[0]), `${id} 域前缀未登记`).toBe(true);
+    }
+  });
+});

package/tsconfig.json

@@ -1,5 +1,5 @@
 {
   "extends": "../../tsconfig.base.json",
   "compilerOptions": {},
-  "include": ["src"]
+  "include": ["src", "tests"]
 }