@openwop/openwop-conformance 1.58.0 → 1.64.0

package/src/scenarios/form-content-packs.test.ts

@@ -0,0 +1,415 @@
+/**
+ * Form-content packs (RFC 0137, `Active`).
+ *
+ * A form-content pack (`kind: "form-content"`) distributes FORM TEMPLATES — a
+ * named, versioned, ordered set of typed input fields a host instantiates into
+ * an ordinary, fully editable form through its normal create path. It is the
+ * sixth declarative pack kind under RFC 0107 and is purely inert: no `runtime`,
+ * no entry point, no handler, no submission surface the host would not
+ * otherwise accept.
+ *
+ * Always-on + server-free. Three parts:
+ *
+ *   PART 1 — contract present. `form-content-packs.md` carries the
+ *   instantiation rules + the F1 trust boundary; `registry-operations.md`
+ *   §"Validation flow" selects the per-kind source schema for `form-content`
+ *   and skips the runtime check for it. Guards against the requirement being
+ *   silently dropped.
+ *
+ *   PART 2 — the version-manifest schema admits the kind and still rejects
+ *   malformed ones. Includes an explicit leg for the `anyOf` payload gate:
+ *   extending the `kind` enum and declaring `templates` is NECESSARY BUT NOT
+ *   SUFFICIENT — without a `templates` branch in `anyOf`, every form-content
+ *   manifest is rejected. That omission is believed to be the second face of
+ *   the CI failure that motivated RFC 0137, so it gets its own assertion.
+ *
+ *   PART 3 — the field vocabulary is SHARED, not forked. `fields[].type` in
+ *   `form-content-pack-manifest.schema.json` MUST be byte-identical to
+ *   `InputField.type` in `chat-card-pack-manifest.schema.json`. Two declarative
+ *   kinds that both collect typed user input, rendered by the same host
+ *   machinery, MUST agree on what a field type means. This is the regression
+ *   guard for RFC 0137 R2: it fails the moment either kind's vocabulary is
+ *   widened alone.
+ *
+ * @see spec/v1/form-content-packs.md
+ * @see spec/v1/chat-card-packs.md §"Input fields — a closed portable subset"
+ * @see spec/v1/registry-operations.md §"Validation flow"
+ * @see schemas/form-content-pack-manifest.schema.json
+ * @see RFCS/0137-form-content-packs.md, RFCS/0107-publishable-declarative-pack-kinds.md
+ */
+
+import { describe, it, expect } from 'vitest';
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import Ajv2020 from 'ajv/dist/2020.js';
+import addFormats from 'ajv-formats';
+import { SCHEMAS_DIR, V1_DIR } from '../lib/paths.js';
+
+const why = (specRef: string, requirement: string): string => `${specRef} — ${requirement}`;
+
+const readSchema = (name: string): Record<string, unknown> =>
+  JSON.parse(readFileSync(join(SCHEMAS_DIR, name), 'utf8'));
+
+describe('form-content-packs: contract present in the corpus (RFC 0137, server-free)', () => {
+  const registryDoc = V1_DIR ? readFileSync(join(V1_DIR, 'registry-operations.md'), 'utf8') : '';
+  const formDoc = V1_DIR ? readFileSync(join(V1_DIR, 'form-content-packs.md'), 'utf8') : '';
+
+  it.skipIf(V1_DIR === null)('registry-operations.md §Validation flow selects the form-content source schema by `kind`', () => {
+    expect(
+      /form-content[\s\S]{0,160}form-content-pack-manifest\.schema\.json/.test(registryDoc),
+      why('registry-operations.md §Validation flow #3', '`kind: "form-content"` validates against its own source schema (RFC 0137)'),
+    ).toBe(true);
+  });
+
+  it.skipIf(V1_DIR === null)('registry-operations.md skips the runtime-support check for form-content', () => {
+    expect(
+      /declarative[\s\S]{0,200}form-content/.test(registryDoc),
+      why('registry-operations.md §Validation flow #7', 'form-content is a declarative kind — the runtime check is skipped'),
+    ).toBe(true);
+  });
+
+  it.skipIf(V1_DIR === null)('registry-operations.md extends the declarative-id denormalization to templateId', () => {
+    expect(
+      /templates\[\]\.templateId/.test(registryDoc),
+      why('registry-operations.md §Type-ID indexing', 'a registry SHOULD denormalize `templates[].templateId` (RFC 0137)'),
+    ).toBe(true);
+  });
+
+  it.skipIf(V1_DIR === null)('form-content-packs.md requires the host to use its NORMAL create path and execute nothing', () => {
+    expect(
+      /MUST[\s\S]{0,120}normal[\s\S]{0,40}create path/i.test(formDoc),
+      why('form-content-packs.md §Instantiation', 'the host MUST instantiate through its normal create path'),
+    ).toBe(true);
+    expect(
+      /MUST NOT execute anything from the pack/i.test(formDoc),
+      why('form-content-packs.md §Instantiation', 'the host MUST NOT execute anything from the pack — the kind is inert'),
+    ).toBe(true);
+  });
+
+  it.skipIf(V1_DIR === null)('form-content-packs.md carries the F1 trust boundary, incl. "a signature is not content trust"', () => {
+    expect(
+      /untrusted/i.test(formDoc) && /contentTrust/.test(formDoc),
+      why('form-content-packs.md §Trust boundary', 'pack-authored strings are untrusted; prompts propagate meta.contentTrust'),
+    ).toBe(true);
+    expect(
+      /signature proves[\s\S]{0,80}not[\s\S]{0,60}trustworthy|MUST NOT treat pack provenance as content trust/i.test(formDoc),
+      why('form-content-packs.md §Trust boundary', 'a signature proves authorship, NOT that the authored bytes are safe'),
+    ).toBe(true);
+    expect(
+      /Length bounds are not a trust boundary/i.test(formDoc),
+      why('form-content-packs.md §Trust boundary', 'maxLength is a resource guard, NOT sanitization'),
+    ).toBe(true);
+  });
+
+  it.skipIf(V1_DIR === null)('the spec distinguishes DEGRADE (well-formed extension) from REFUSE (malformed value)', () => {
+    expect(
+      /Degrade applies to \*extensions\*, not to malformed values/i.test(formDoc),
+      why('form-content-packs.md §Instantiation', 'MUST-degrade is scoped to vendor.*/x- extensions, not bare unknowns'),
+    ).toBe(true);
+    expect(
+      /MUST NOT collapse these into one rule in either direction/i.test(formDoc),
+      why(
+        'form-content-packs.md §Instantiation',
+        'refusing a well-formed extension breaks forward compat; degrading a malformed value hides an authoring error',
+      ),
+    ).toBe(true);
+  });
+
+  it.skipIf(V1_DIR === null)('form-content-packs.md forbids minting a second field-type vocabulary', () => {
+    expect(
+      /MUST NOT\W{0,4}\s*define its own field-type vocabulary/i.test(formDoc),
+      why('form-content-packs.md §Field types', 'the kind reuses the RFC 0071 portable subset rather than defining its own'),
+    ).toBe(true);
+  });
+});
+
+describe('form-content-packs: version-manifest schema admits the kind (RFC 0137, server-free)', () => {
+  const ajv = new Ajv2020({ allErrors: true, strict: false });
+  addFormats(ajv);
+  const versionManifestSchema = readSchema('registry-version-manifest.schema.json');
+  const validate = ajv.compile(versionManifestSchema);
+
+  const base = { name: 'core.openwop.forms', version: '1.0.0', engines: { openwop: '>=1.0.0' }, integrity: 'sha256-abc=' };
+  const template = {
+    templateId: 'core.openwop.form.rsvp',
+    version: '1.0.0',
+    label: 'RSVP',
+    title: 'Will you be joining us?',
+    fields: [{ id: 'guestName', type: 'text', label: 'Your name' }],
+  };
+
+  it('`form-content` is in the kind enum and `templates` is a declared property', () => {
+    const props = (versionManifestSchema.properties ?? {}) as Record<string, { enum?: string[] }>;
+    expect(props.kind?.enum, why('registry-version-manifest.schema.json', '`form-content` joins the kind enum (RFC 0137)')).toEqual(
+      expect.arrayContaining(['node', 'artifact-type', 'connection', 'card', 'form-content']),
+    );
+    expect(!!props.templates, why('registry-version-manifest.schema.json', '`templates` payload property declared (additionalProperties:false)')).toBe(true);
+  });
+
+  it('the `anyOf` payload gate carries a `templates` branch (NECESSARY — enum + property alone are not sufficient)', () => {
+    const anyOf = (versionManifestSchema.anyOf ?? []) as Array<{ required?: string[] }>;
+    expect(
+      anyOf.some((branch) => (branch.required ?? []).includes('templates')),
+      why('registry-version-manifest.schema.json §anyOf', 'without a `templates` branch every form-content manifest is rejected (RFC 0137 §Proposal 1)'),
+    ).toBe(true);
+  });
+
+  it('a published form-content version manifest validates (kind + templates, no runtime)', () => {
+    const ok = validate({ ...base, kind: 'form-content', templates: [template] });
+    expect(ok, why('registry-operations.md §Validation flow', 'form-content manifest publishes (RFC 0137)')).toBe(true);
+  });
+
+  it('a form-content manifest carrying `runtime` is REJECTED (declarative kinds carry no runtime)', () => {
+    const ok = validate({ ...base, kind: 'form-content', templates: [template], runtime: { language: 'javascript' } });
+    expect(ok, why('registry-version-manifest.schema.json §allOf', 'a declarative kind MUST NOT carry runtime')).toBe(false);
+  });
+
+  it('an unchanged node version manifest still validates (RFC 0137 is additive)', () => {
+    const ok = validate({
+      ...base,
+      runtime: { language: 'javascript' },
+      nodes: [{ typeId: 'core.openwop.x.n', version: '1.0.0', category: 'data', role: 'pure' }],
+    });
+    expect(ok, why('COMPATIBILITY.md §2.1', 'RFC 0137 is additive — node manifests validate unchanged')).toBe(true);
+  });
+});
+
+describe('form-content-packs: source manifest contract (RFC 0137, server-free)', () => {
+  const ajv = new Ajv2020({ allErrors: true, strict: false });
+  addFormats(ajv);
+  const sourceSchema = readSchema('form-content-pack-manifest.schema.json');
+  const validate = ajv.compile(sourceSchema);
+
+  const pack = (templates: unknown[]): Record<string, unknown> => ({
+    name: 'core.openwop.forms.starters',
+    version: '1.0.0',
+    kind: 'form-content',
+    engines: { openwop: '>=1.1.0 <2.0.0' },
+    templates,
+  });
+  const field = (over: Record<string, unknown> = {}): Record<string, unknown> => ({
+    id: 'guestName',
+    type: 'text',
+    label: 'Your name',
+    ...over,
+  });
+  const template = (over: Record<string, unknown> = {}): Record<string, unknown> => ({
+    templateId: 'core.openwop.form.rsvp',
+    version: '1.0.0',
+    label: 'RSVP',
+    title: 'Will you be joining us?',
+    fields: [field()],
+    ...over,
+  });
+
+  it('schema discipline: draft 2020-12, canonical $id, closed objects', () => {
+    expect(sourceSchema.$schema, why('CONTRIBUTING.md §JSON Schemas', 'draft 2020-12')).toBe(
+      'https://json-schema.org/draft/2020-12/schema',
+    );
+    expect(sourceSchema.$id, why('CONTRIBUTING.md §JSON Schemas', 'canonical $id URL')).toBe(
+      'https://openwop.dev/spec/v1/form-content-pack-manifest.schema.json',
+    );
+    expect(sourceSchema.additionalProperties, why('CONTRIBUTING.md §JSON Schemas', 'additionalProperties:false')).toBe(false);
+  });
+
+  it('a well-formed form-content pack validates', () => {
+    expect(validate(pack([template()])), why('form-content-packs.md §Manifest format', 'the canonical example validates')).toBe(true);
+  });
+
+  it('the full portable field-type subset is accepted', () => {
+    for (const type of ['text', 'longtext', 'number', 'boolean', 'select', 'multiselect', 'file', 'artifact-ref']) {
+      expect(
+        validate(pack([template({ fields: [field({ type })] })])),
+        why('chat-card-packs.md §Input fields', `portable type \`${type}\` is accepted (RFC 0071 G9 subset)`),
+      ).toBe(true);
+    }
+  });
+
+  it('vendor.* and x- host extensions are accepted (other hosts degrade to plain text)', () => {
+    for (const type of ['vendor.myndhyve.color', 'x-signature-pad']) {
+      expect(
+        validate(pack([template({ fields: [field({ type })] })])),
+        why('form-content-packs.md §Field types', `host extension \`${type}\` is accepted`),
+      ).toBe(true);
+    }
+  });
+
+  it('`email` and `textarea` are REJECTED as field types (they are a format and a widget)', () => {
+    expect(
+      validate(pack([template({ fields: [field({ type: 'email' })] })])),
+      why('form-content-packs.md §Validation formats are not types', '`email` is a format constraint, not a data kind — use text + format'),
+    ).toBe(false);
+    expect(
+      validate(pack([template({ fields: [field({ type: 'textarea' })] })])),
+      why('chat-card-packs.md §Input fields', '`textarea` is a widget name — the portable data kind is `longtext`'),
+    ).toBe(false);
+  });
+
+  it('`format: "email"` on a text field IS accepted (the supported spelling)', () => {
+    expect(
+      validate(pack([template({ fields: [field({ id: 'email', type: 'text', format: 'email' })] })])),
+      why('form-content-packs.md §Validation formats are not types', 'email validation rides `format`, not `type`'),
+    ).toBe(true);
+  });
+
+  it('a field using `key` instead of `id` is REJECTED (aligns with chat-card InputField.id)', () => {
+    const bad = { key: 'guestName', type: 'text', label: 'Your name' };
+    expect(
+      validate(pack([template({ fields: [bad] })])),
+      why('form-content-packs.md §Manifest format', 'the field identifier is `id`, not `key`'),
+    ).toBe(false);
+  });
+
+  it('an integer `templates[].version` is REJECTED (SemVer axis, not the integer schemaVersion axis)', () => {
+    expect(
+      validate(pack([template({ version: 3 })])),
+      why('form-content-packs.md §Manifest format', '`templates[].version` is SemVer 2.0.0'),
+    ).toBe(false);
+  });
+
+  it('an empty `fields[]` and an empty `templates[]` are REJECTED', () => {
+    expect(validate(pack([template({ fields: [] })])), why('form-content-pack-manifest.schema.json', 'a template MUST declare ≥1 field')).toBe(false);
+    expect(validate(pack([])), why('form-content-pack-manifest.schema.json', 'a pack MUST declare ≥1 template')).toBe(false);
+  });
+
+  it('a `runtime` block is REJECTED at the source manifest too (the kind is inert)', () => {
+    expect(
+      validate({ ...pack([template()]), runtime: { language: 'javascript' } }),
+      why('form-content-packs.md §Pack kind', 'a form-content pack carries no runtime'),
+    ).toBe(false);
+  });
+});
+
+describe('form-content-packs: a template carries NO submission routing (RFC 0137 §F2, invariant)', () => {
+  const ajv = new Ajv2020({ allErrors: true, strict: false });
+  addFormats(ajv);
+  const sourceSchema = readSchema('form-content-pack-manifest.schema.json') as {
+    $defs: { FormTemplate: { properties: Record<string, unknown>; additionalProperties?: boolean } };
+  };
+  const validate = ajv.compile(sourceSchema);
+  const formDoc = V1_DIR ? readFileSync(join(V1_DIR, 'form-content-packs.md'), 'utf8') : '';
+
+  const withTemplateKey = (key: string, value: unknown): Record<string, unknown> => ({
+    name: 'core.openwop.forms.starters',
+    version: '1.0.0',
+    kind: 'form-content',
+    engines: { openwop: '>=1.1.0 <2.0.0' },
+    templates: [
+      {
+        templateId: 'core.openwop.form.rsvp',
+        version: '1.0.0',
+        label: 'RSVP',
+        title: 'RSVP',
+        fields: [{ id: 'a', type: 'text', label: 'A' }],
+        [key]: value,
+      },
+    ],
+  });
+
+  it('FormTemplate declares NO routing-shaped property and is closed', () => {
+    const props = Object.keys(sourceSchema.$defs.FormTemplate.properties);
+    for (const banned of ['intakeBinding', 'destination', 'webhook', 'webhookUrl', 'listId', 'mailbox', 'crmObject', 'routing', 'submitTo']) {
+      expect(props, why('form-content-packs.md §No submission routing', `FormTemplate MUST NOT declare a \`${banned}\` property`)).not.toContain(banned);
+    }
+    expect(
+      sourceSchema.$defs.FormTemplate.additionalProperties,
+      why('form-content-packs.md §No submission routing', 'FormTemplate is closed, so an undeclared routing key is rejected'),
+    ).toBe(false);
+  });
+
+  it('a template attempting to carry routing config is REJECTED', () => {
+    for (const [key, value] of [
+      ['intakeBinding', { listId: 'abc' }],
+      ['destination', 'https://attacker.example/collect'],
+      ['webhookUrl', 'https://attacker.example/hook'],
+    ] as Array<[string, unknown]>) {
+      expect(
+        validate(withTemplateKey(key, value)),
+        why('form-content-packs.md §No submission routing', `a pack MUST NOT bind a submission destination via \`${key}\``),
+      ).toBe(false);
+    }
+  });
+
+  it.skipIf(V1_DIR === null)('the spec scopes the routing ban to the PACK, leaving operator-configured routing free', () => {
+    expect(
+      /This constrains the pack, not the host/i.test(formDoc),
+      why('form-content-packs.md §No submission routing', 'a host MAY route wherever its OPERATOR configures; only pack-declared routing is banned'),
+    ).toBe(true);
+  });
+
+  it.skipIf(V1_DIR === null)('the spec binds FUTURE routing surfaces to operator consent, not pack declaration', () => {
+    expect(
+      /MUST NOT let a pack bind a destination unilaterally|routing MUST be a host-side decision/i.test(formDoc),
+      why('form-content-packs.md §No submission routing', 'a later routing RFC MUST keep the decision host-side, behind operator consent'),
+    ).toBe(true);
+  });
+});
+
+describe('form-content-packs: identifier uniqueness + resource bounds (RFC 0137 amendment)', () => {
+  const formDoc = V1_DIR ? readFileSync(join(V1_DIR, 'form-content-packs.md'), 'utf8') : '';
+  const sourceSchema = readSchema('form-content-pack-manifest.schema.json') as {
+    properties: { templates: { maxItems: number } };
+    $defs: {
+      FormTemplate: { properties: { fields: { maxItems: number } } };
+      FormField: { properties: { label: { maxLength: number }; options: { maxItems: number } } };
+    };
+  };
+
+  it.skipIf(V1_DIR === null)('duplicate `fields[].id` is a normative refusal, framed as data integrity', () => {
+    expect(
+      /each `fields\[\]\.id` MUST be unique within its template/i.test(formDoc),
+      why('form-content-packs.md §Unique identifiers', 'duplicate field ids MUST be refused'),
+    ).toBe(true);
+    expect(
+      /silently overwrite/i.test(formDoc),
+      why('form-content-packs.md §Unique identifiers', 'the rationale is silent data loss, not style'),
+    ).toBe(true);
+  });
+
+  it('resource bounds admit real-world content (long consent labels, a country list)', () => {
+    expect(
+      sourceSchema.$defs.FormField.properties.label.maxLength,
+      why('form-content-pack-manifest.schema.json', 'a lawful consent label is legitimately long-form'),
+    ).toBeGreaterThanOrEqual(1000);
+    expect(
+      sourceSchema.$defs.FormField.properties.options.maxItems,
+      why('form-content-pack-manifest.schema.json', 'a country list is ~195 entries — the cap must clear it'),
+    ).toBeGreaterThanOrEqual(250);
+  });
+
+  it('outer resource caps exist on both arrays (render-bomb guard, not product policy)', () => {
+    expect(sourceSchema.properties.templates.maxItems, why('form-content-pack-manifest.schema.json', 'templates[] carries an outer cap')).toBeGreaterThan(0);
+    expect(sourceSchema.$defs.FormTemplate.properties.fields.maxItems, why('form-content-pack-manifest.schema.json', 'fields[] carries an outer cap')).toBeGreaterThan(0);
+  });
+});
+
+describe('form-content-packs: the field vocabulary is SHARED with chat-card packs, not forked (RFC 0137 R2)', () => {
+  const formSchema = readSchema('form-content-pack-manifest.schema.json') as {
+    $defs: { FormField: { properties: { type: { pattern: string } } } };
+  };
+  const cardSchema = readSchema('chat-card-pack-manifest.schema.json') as {
+    $defs: { InputField: { properties: { type: { pattern: string } } } };
+  };
+
+  it('`fields[].type` and `inputs[].type` share one byte-identical pattern', () => {
+    const formPattern = formSchema.$defs.FormField.properties.type.pattern;
+    const cardPattern = cardSchema.$defs.InputField.properties.type.pattern;
+    expect(
+      formPattern,
+      why(
+        'form-content-packs.md §Field types',
+        'RFC 0137 reuses the RFC 0071 portable subset VERBATIM — two input-collecting declarative kinds MUST agree on what a field type means. If this fails, one kind\'s vocabulary was widened without the other and the wire contract has forked.',
+      ),
+    ).toBe(cardPattern);
+  });
+
+  it('the shared pattern still admits every portable data kind and both extension prefixes', () => {
+    const pattern = new RegExp(formSchema.$defs.FormField.properties.type.pattern);
+    for (const type of ['text', 'longtext', 'number', 'boolean', 'select', 'multiselect', 'file', 'artifact-ref']) {
+      expect(pattern.test(type), why('chat-card-packs.md §Input fields', `\`${type}\` is in the portable subset`)).toBe(true);
+    }
+    expect(pattern.test('vendor.acme.rating'), why('chat-card-packs.md §Input fields', 'vendor.<org>.<kind> extensions are admitted')).toBe(true);
+    expect(pattern.test('x-rating'), why('chat-card-packs.md §Input fields', 'x-<kind> extensions are admitted')).toBe(true);
+    expect(pattern.test('textarea'), why('chat-card-packs.md §Input fields', 'widget names are NOT in the subset')).toBe(false);
+  });
+});

package/src/scenarios/pack-manifest-extension-opacity.test.ts

@@ -0,0 +1,179 @@
+/**
+ * pack-manifest-extension-opacity — RFC 0139, the host-side witness for
+ * RFC 0138's "ignore means ignore" clause.
+ *
+ * RFC 0138 made pack manifests carry `^(x-|vendor\.)` extensions and defined
+ * ignoring one normatively: a consumer MUST NOT render it, execute it,
+ * interpret it as markup or a templating directive, use it to select a code
+ * path, or persist it into a surface where it will later be interpreted.
+ * All 19 of RFC 0138's assertions are SERVER-FREE — they check that schemas
+ * admit the hatch and that the corpus states the rule. **Nothing verified any
+ * of it against a host.**
+ *
+ * ## Why presence is not the assertion
+ *
+ * The obvious leg — install an extension-bearing manifest, assert 2xx —
+ * proves almost nothing. A host that stores `x-evil.template` and later
+ * interpolates it into a rendered surface PASSES it. That is precisely the
+ * failure RFC 0138 calls "strictly worse than no hatch", because it converts
+ * a loud publication failure into a silent injection surface.
+ *
+ * ## The differential
+ *
+ * The load-bearing leg is **leg 3**: install the same manifest with and
+ * without an unrecognized extension and require the host's registration
+ * projection to be IDENTICAL (modulo the extension properties themselves).
+ *
+ * This is sink-agnostic. It does not ask WHERE an extension might leak — a
+ * suite cannot enumerate a host's sinks — it asks whether the host's
+ * observable behavior is a function of the extension at all. If it is not,
+ * every install-time sink is covered at once.
+ *
+ * The extension namespace is `vendor.conformance.*`, which no host can claim
+ * to recognize, so the UNRECOGNIZED branch is the one exercised. A host that
+ * recognizes and acts on its own extension is out of scope for this rule.
+ *
+ * ## WHAT THIS DOES NOT DISCRIMINATE — read before citing a green run
+ *
+ *  - **A host that stores the extension and interprets it later**, at a
+ *    moment this seam never reaches. Leg 3 covers INSTALL-TIME sinks only.
+ *    No finite suite closes this; see RFC 0139 gap G3.
+ *  - **A host that fakes the seam** by returning a constant projection.
+ *    Legs 2 and 5 constrain the projection to be a function of something,
+ *    but host-sample seams measure COOPERATING hosts — they are not an
+ *    adversarial control (RFC 0139 risk R3).
+ *  - **Pack kinds other than artifact-type.** Only this seam has a real host
+ *    behind it; a speculative leg on an unimplemented kind would soft-skip
+ *    everywhere and add coverage theatre (gap G2).
+ *  - **`artifact.created` carrying `artifactType`** (RFC 0138 gap G8). This
+ *    seam emits no run events — the reference host emits `artifact.created`
+ *    only from a real run, not from `persistRunArtifact`. Explicitly out of
+ *    scope rather than folded in to produce a green that covers nothing.
+ *
+ * Gated on `behaviorGate`, never a bare `return`: a host that advertises
+ * `artifactTypes.supported` and serves no seam FAILS under
+ * `OPENWOP_REQUIRE_BEHAVIOR=true` rather than reporting green.
+ *
+ * @see RFCS/0139-extension-opacity-host-witness.md
+ * @see spec/v1/node-packs.md §"Vendor extensions on pack manifests"
+ * @see SECURITY/invariants.yaml `pack-manifest-extension-opaque`
+ */
+
+import { describe, it, expect } from 'vitest';
+import { driver } from '../lib/driver.js';
+import { behaviorGate, behaviorGatePresent } from '../lib/behavior-gate.js';
+import {
+  readArtifactTypesCap,
+  artifactTypesSupported,
+  installArtifactTypePack,
+  sampleArtifactTypePack,
+  stripExtensions,
+  withExtensions,
+  canonicalJson,
+} from '../lib/artifactTypes.js';
+
+const PROFILE = 'openwop-artifact-type-packs';
+
+/** An extension no host can claim to recognize — forces the unrecognized branch. */
+const INERT_EXT = { 'vendor.conformance.opacity': { note: 'unrecognized by construction' } };
+
+/** An extension whose VALUE is markup + a templating directive. */
+const HOSTILE_EXT = {
+  'vendor.conformance.hostile': {
+    markup: '<img src=x onerror="alert(1)">',
+    template: '{{constructor.constructor("return 1")()}}',
+    directive: '${jndi:ldap://example.invalid/a}',
+  },
+};
+
+/** Installs `manifest`, returning the projection or null when the seam is absent. */
+async function install(manifest: unknown): Promise<{ status: number; json: unknown } | null> {
+  const { artifactTypeId, schema } = sampleArtifactTypePack();
+  return installArtifactTypePack(manifest, { [artifactTypeId]: schema });
+}
+
+const ok = (status: number): boolean => status >= 200 && status < 300;
+
+describe('pack-manifest-extension-opacity: a host MUST accept an extended manifest (RFC 0139)', () => {
+  it('leg 1 — an extension-bearing manifest installs', async () => {
+    if (!behaviorGate(PROFILE, artifactTypesSupported(await readArtifactTypesCap()))) return;
+    const { manifest } = sampleArtifactTypePack();
+    const res = await install(withExtensions(manifest, INERT_EXT));
+    if (!behaviorGatePresent(PROFILE, res)) return; // seam absent: skip default, FAIL strict
+    expect(
+      ok(res.status),
+      driver.describe('node-packs.md §"Vendor extensions on pack manifests"', 'a consumer MUST ignore an unrecognized extension and MUST NOT reject the pack for its presence'),
+    ).toBe(true);
+  });
+
+  it('leg 2 — the same manifest WITHOUT the extension installs (baseline)', async () => {
+    if (!behaviorGate(PROFILE, artifactTypesSupported(await readArtifactTypesCap()))) return;
+    const { manifest } = sampleArtifactTypePack();
+    const res = await install(manifest);
+    if (!behaviorGatePresent(PROFILE, res)) return;
+    expect(
+      ok(res.status),
+      driver.describe('RFC 0139 §Conformance', 'baseline — guards against a differential that passes because EVERYTHING fails'),
+    ).toBe(true);
+  });
+});
+
+describe('pack-manifest-extension-opacity: the differential — behavior MUST NOT be a function of the extension (RFC 0139)', () => {
+  it('leg 3 — projections for M and M′ are equal modulo the extensions [LOAD-BEARING]', async () => {
+    if (!behaviorGate(PROFILE, artifactTypesSupported(await readArtifactTypesCap()))) return;
+    const { manifest } = sampleArtifactTypePack();
+
+    const plain = await install(manifest);
+    if (!behaviorGatePresent(PROFILE, plain)) return;
+    const extended = await install(withExtensions(manifest, INERT_EXT));
+    if (!behaviorGatePresent(PROFILE, extended)) return;
+
+    expect(
+      ok(plain.status) === ok(extended.status),
+      driver.describe('RFC 0139 §"The differential-install contract"', 'acceptance MUST NOT be a function of an unrecognized extension — a host MUST accept both or reject both for the same reason'),
+    ).toBe(true);
+
+    expect(
+      canonicalJson(stripExtensions(extended.json)),
+      driver.describe('RFC 0139 §"The differential-install contract"', 'the registration projection MUST be identical modulo the extension properties — a difference means the host acted on an extension it does not recognize (rendering catalog, derived facet, or code-path switch)'),
+    ).toBe(canonicalJson(stripExtensions(plain.json)));
+  });
+
+  it('leg 4 — an extension carrying markup / a templating directive is not interpreted at install', async () => {
+    if (!behaviorGate(PROFILE, artifactTypesSupported(await readArtifactTypesCap()))) return;
+    const { manifest } = sampleArtifactTypePack();
+
+    const plain = await install(manifest);
+    if (!behaviorGatePresent(PROFILE, plain)) return;
+    const hostile = await install(withExtensions(manifest, HOSTILE_EXT));
+    if (!behaviorGatePresent(PROFILE, hostile)) return;
+
+    expect(
+      ok(hostile.status),
+      driver.describe('node-packs.md §"Vendor extensions on pack manifests"', 'an extension value is PACK-AUTHORED and therefore untrusted, but untrusted is not a rejection reason — the host MUST install and ignore'),
+    ).toBe(true);
+
+    expect(
+      canonicalJson(stripExtensions(hostile.json)),
+      driver.describe('node-packs.md §"Vendor extensions on pack manifests"', 'MUST NOT render it, execute it, or interpret it as markup or a templating directive — a projection that differs from baseline means the value reached an interpreter'),
+    ).toBe(canonicalJson(stripExtensions(plain.json)));
+  });
+});
+
+describe('pack-manifest-extension-opacity: the HOST reader stays narrow (RFC 0139 leg 5)', () => {
+  it('leg 5 — a misspelled canonical field is still rejected by the host, not merely by the schema', async () => {
+    if (!behaviorGate(PROFILE, artifactTypesSupported(await readArtifactTypesCap()))) return;
+    const { manifest } = sampleArtifactTypePack();
+
+    // `dispalyName` matches no canonical property and no extension pattern.
+    const typo = JSON.parse(JSON.stringify(manifest)) as Record<string, unknown>;
+    (typo['artifactTypes'] as Record<string, unknown>[])[0]!['dispalyName'] = 'Note';
+
+    const res = await install(typo);
+    if (!behaviorGatePresent(PROFILE, res)) return;
+    expect(
+      ok(res.status),
+      driver.describe('node-packs.md §"Vendor extensions on pack manifests"', 'the hatch admits DECLARED extensions, not arbitrary keys — a host that widened its own reader to additionalProperties:true to "support extensions" accepts everything, which is not the same as accepting extensions'),
+    ).toBe(false);
+  });
+});