@usefragments/core 1.10.2 → 2.0.0

package/src/rules/rules.test.ts

@@ -1540,6 +1540,32 @@ describe("runRules — Phase 5 vertical slice", () => {
     }
   });
 
+  it("never runs a rule whose governance_rule_config fact is disabled", () => {
+    // `govern.rules["styles/no-raw-spacing"] = { enabled: false }` compiles to a
+    // rule-config fact. Enablement is honoured INSIDE runRules so the engine scan
+    // and the kernel's facts-mode evaluation agree on which rules exist — a
+    // post-filter in one evaluator is how a disabled rule blocked `--ci`.
+    const ix = emptyIndexWithGovernance();
+    ix.add(makeGovernanceRuleConfigFact({ ruleId: "styles/no-raw-spacing", enabled: false }));
+    addButtonUsage(ix, {
+      file: "apps/checkout/page.tsx",
+      nodePath: "0/0",
+      line: 42,
+      column: 8,
+      props: [{ prop: "variant", value: "secondary" }],
+      inlineStyles: [
+        { property: "padding", valueKind: "number", value: "13" },
+        { property: "color", valueKind: "static", value: "#2563eb" },
+      ],
+      text: "Continue",
+    });
+
+    const ruleIds = runRules(ix)
+      .map((f) => f.ruleId)
+      .sort();
+    expect(ruleIds).toEqual(["components/forbidden-prop-value", "styles/no-raw-color"]);
+  });
+
   it("emits stable fingerprints across runs", () => {
     function buildIndex(): FactIndex {
       const ix = emptyIndexWithGovernance();

package/src/rules/tokens-css-vars-must-be-defined.test.ts

@@ -1,6 +1,7 @@
 import { describe, expect, it } from "vitest";
 
 import {
+  compileGlobalGovernanceFacts,
   FactIndex,
   makeContractTokenFact,
   makeStyleCssVarsMustBeDefinedFact,
@@ -9,6 +10,7 @@ import {
 import type { Fact } from "../index.js";
 import {
   contractTokenReferenceCensus,
+  emptyVocabularyConfigFile,
   ruleTokensCssVarsMustBeDefined,
 } from "./tokens-css-vars-must-be-defined.js";
 
@@ -121,10 +123,45 @@ describe("ruleTokensCssVarsMustBeDefined", () => {
     expect(ruleTokensCssVarsMustBeDefined(ix)).toHaveLength(0);
   });
 
-  it("is INERT when the contract vocabulary is empty (no token definitions)", () => {
+  it("does not compile an activation fact from a rules-map enablement alone", () => {
+    const facts = compileGlobalGovernanceFacts({
+      rules: { "tokens/css-vars-must-be-defined": { enabled: true, severity: "error" } },
+    });
+    expect(facts.some((fact) => fact.kind === "style_css_vars_must_be_defined")).toBe(false);
+  });
+
+  it("emits one config-level inert finding when the contract vocabulary is empty", () => {
     const ix = index([POLICY, decl(".b", "var(--fui-color-brand)")]);
 
-    expect(ruleTokensCssVarsMustBeDefined(ix)).toHaveLength(0);
+    const findings = ruleTokensCssVarsMustBeDefined(ix);
+    expect(findings).toHaveLength(1);
+    expect(findings[0]).toMatchObject({
+      ruleId: "tokens/css-vars-must-be-defined",
+      code: "FUI2018",
+      severity: "serious",
+      message: "token sources resolved to 0 tokens — rule inert",
+      location: { file: "your fragments config", line: 0, column: 0 },
+      attributes: { inert: true, tokenCount: 0, source: "config" },
+    });
+  });
+
+  it("points the inert finding at the resolved config path when the policy fact carries it", () => {
+    const policy = makeStyleCssVarsMustBeDefinedFact({
+      severity: "warn",
+      configPath: "fragments.config.json",
+    });
+    const findings = ruleTokensCssVarsMustBeDefined(index([policy]));
+    expect(findings).toHaveLength(1);
+    expect(findings[0].location.file).toBe("fragments.config.json");
+  });
+
+  it("keeps ordinary drift findings when the vocabulary is non-empty", () => {
+    const ix = index([POLICY, ...vocabulary(), decl(".b", "var(--fui-color-brand)")]);
+
+    const findings = ruleTokensCssVarsMustBeDefined(ix);
+    expect(findings).toHaveLength(1);
+    expect(findings[0].code).toBe("FUI2015");
+    expect(findings[0].attributes).toMatchObject({ tokenName: "--fui-color-brand" });
   });
 
   // #33 — CSS function names are case-insensitive; VAR()/Var() must be detected.
@@ -307,3 +344,15 @@ describe("contractTokenReferenceCensus", () => {
     expect(census).toEqual({ checkedSites: 0 });
   });
 });
+
+describe("emptyVocabularyConfigFile", () => {
+  it("uses the resolved filename when a path is present", () => {
+    expect(emptyVocabularyConfigFile("fragments.config.json")).toBe("fragments.config.json");
+    expect(emptyVocabularyConfigFile("apps/docs/fragments.config.ts")).toBe("fragments.config.ts");
+  });
+
+  it("drops the filename when the path is missing", () => {
+    expect(emptyVocabularyConfigFile(undefined)).toBe("your fragments config");
+    expect(emptyVocabularyConfigFile(null)).toBe("your fragments config");
+  });
+});

package/src/rules/tokens-css-vars-must-be-defined.ts

@@ -3,9 +3,20 @@ import type { FactIndex } from "../facts/index.js";
 import { makeFinding } from "./finding.js";
 import type { Finding } from "./types.js";
 import { contractPrefixFamilies } from "./utils.js";
+import type { StyleCssVarsMustBeDefinedFact } from "../facts/index.js";
 
 export const RULE_ID = "tokens/css-vars-must-be-defined";
 export const RULE_VERSION = "1";
+export const EMPTY_VOCABULARY_CODE = "FUI2018";
+export const EMPTY_VOCABULARY_MESSAGE = "token sources resolved to 0 tokens — rule inert";
+export const EMPTY_VOCABULARY_CONFIG_FALLBACK = "your fragments config";
+
+/** Filename of the resolved fragments config, or a filename-free fallback. */
+export function emptyVocabularyConfigFile(configPath?: string | null): string {
+  if (!configPath) return EMPTY_VOCABULARY_CONFIG_FALLBACK;
+  const base = configPath.replaceAll("\\", "/").replace(/\/+$/u, "").split("/").pop();
+  return base && base.length > 0 ? base : EMPTY_VOCABULARY_CONFIG_FALLBACK;
+}
 
 // The leading `var(--name` of a reference. The `var(` keyword is matched
 // case-insensitively (CSS function names are case-insensitive per spec, so
@@ -101,7 +112,7 @@ export function ruleTokensCssVarsMustBeDefined(ix: FactIndex): Finding[] {
   const policy = ix.policy.cssVarsMustBeDefined();
   if (!policy) return [];
   const context = contractVocabularyContext(ix);
-  if (!context) return [];
+  if (!context) return [emptyVocabularyFinding(ix, policy)];
   const { vocabulary } = context;
 
   const findings: Finding[] = [];
@@ -155,6 +166,28 @@ export function ruleTokensCssVarsMustBeDefined(ix: FactIndex): Finding[] {
   return findings;
 }
 
+function emptyVocabularyFinding(ix: FactIndex, policy: StyleCssVarsMustBeDefinedFact): Finding {
+  return makeFinding({
+    ruleId: RULE_ID,
+    ruleVersion: RULE_VERSION,
+    severity: "error",
+    code: EMPTY_VOCABULARY_CODE,
+    message: EMPTY_VOCABULARY_MESSAGE,
+    location: {
+      file: policy.configPath ?? EMPTY_VOCABULARY_CONFIG_FALLBACK,
+      line: 0,
+      column: 0,
+    },
+    evidence: ix.evidence([policy.id]),
+    fingerprintIdentity: { reason: "empty-vocabulary" },
+    attributes: {
+      source: "config",
+      inert: true,
+      tokenCount: 0,
+    },
+  });
+}
+
 function sharesContractPrefix(name: string, prefixes: ReadonlySet<string>): boolean {
   for (const prefix of prefixes) {
     if (name.startsWith(prefix)) return true;

package/src/schema.ts

@@ -1,4 +1,17 @@
 import { z } from "zod";
+import type {
+  FragmentAnnotationsV3,
+  FragmentDefinitionV3,
+  FragmentDefinitionV3Body,
+  FragmentDesignV3,
+  FragmentDontExampleV3,
+  FragmentGuidanceV3,
+  FragmentMatrixV3,
+  FragmentMetaV3,
+  FragmentPreviewV3,
+  FragmentStateV3,
+  PropAnnotation,
+} from "./types.js";
 import { portableRepoPathError } from "./config-paths.js";
 import { componentGovernanceRecordSchema, governanceConfigSchema } from "./governance.js";
 import { compositionAuthoringEntrySchema } from "./rules/composition-pattern-schema.js";
@@ -13,10 +26,15 @@ const figmaStringMappingSchema = z.object({
   figmaProperty: z.string().min(1),
 });
 
+const requiredUnknownSchema = z.custom<unknown>(
+  (value) => value !== undefined,
+  "Expected an explicitly present value"
+);
+
 const figmaBooleanMappingSchema = z.object({
   __type: z.literal("figma-boolean"),
   figmaProperty: z.string().min(1),
-  valueMapping: z.object({ true: z.unknown(), false: z.unknown() }).optional(),
+  valueMapping: z.object({ true: requiredUnknownSchema, false: requiredUnknownSchema }).optional(),
 });
 
 const figmaEnumMappingSchema = z.object({
@@ -143,7 +161,7 @@ export const fragmentContractSchema = z.object({
   a11yRules: z.array(z.string()).optional(),
   bans: z.array(fragmentBanSchema).optional(),
   scenarioTags: z.array(z.string()).optional(),
-  performanceBudget: z.number().positive().optional(),
+  performanceBudget: z.number().positive().finite().optional(),
   compoundChildren: z
     .record(
       z.object({
@@ -163,10 +181,21 @@ export const fragmentContractSchema = z.object({
 /**
  * Schema for provenance tracking of generated fragments
  */
+export const fragmentSourceValues = [
+  "storybook",
+  "manual",
+  "ai",
+  "scan",
+  "extracted",
+  "merged",
+  "migrated",
+] as const;
+
 export const fragmentGeneratedSchema = z.object({
-  source: z.enum(["storybook", "manual", "ai"]),
+  source: z.enum(fragmentSourceValues),
   sourceFile: z.string().optional(),
   confidence: z.number().min(0).max(1).optional(),
+  verified: z.boolean().optional(),
   timestamp: z.string().datetime().optional(),
 });
 
@@ -299,102 +328,92 @@ const topologySchema = z.object({
  * Type definitions are in types.ts - schema just ensures basic structure.
  */
 export const fragmentsConfigSchema = z.object({
-  app: z
-    .object({
-      path: repoRelativePathSchema.optional(),
-      include: repoRelativePathsSchema.optional(),
-      exclude: z.array(repoRelativePathSchema).optional(),
-    })
-    .optional(),
-  designSystem: z
-    .object({
-      path: repoRelativePathSchema.optional(),
-      packageName: z.string().min(1).optional(),
-      components: repoRelativePathsSchema.optional(),
-    })
-    .optional(),
-  include: repoRelativePathsSchema.optional(),
-  exclude: z.array(repoRelativePathSchema).optional(),
-  components: repoRelativePathsSchema.optional(),
-  outFile: repoRelativePathSchema.optional(),
-  framework: z.enum(["react", "vue", "svelte"]).optional(),
-  figmaFile: z.string().url().optional(),
-  figmaToken: z.string().optional(),
-  screenshots: z.object({}).passthrough().optional(),
-  service: z.object({}).passthrough().optional(),
-  registry: z.object({}).passthrough().optional(),
-  tokens: tokenConfigSchema.optional(),
-  snippets: z
-    .object({
-      mode: z.enum(["warn", "error"]).optional(),
-      scope: z.enum(["snippet", "snippet+render"]).optional(),
-      requireFullSnippet: z.boolean().optional(),
-      allowedExternalModules: z.array(z.string().min(1)).optional(),
-    })
-    .optional(),
-  performance: z
-    .union([
-      z.enum(["strict", "standard", "relaxed"]),
-      z.object({
-        preset: z.enum(["strict", "standard", "relaxed"]).optional(),
-        budgets: z
-          .object({
-            bundleSize: z.number().positive().optional(),
-          })
+    app: z
+      .object({
+        path: repoRelativePathSchema.optional(),
+        include: repoRelativePathsSchema.optional(),
+        exclude: z.array(repoRelativePathSchema).optional(),
+      })
+      .optional(),
+    designSystem: z
+      .object({
+        path: repoRelativePathSchema.optional(),
+        packageName: z.string().min(1).optional(),
+        components: repoRelativePathsSchema.optional(),
+      })
+      .optional(),
+    include: repoRelativePathsSchema.optional(),
+    exclude: z.array(repoRelativePathSchema).optional(),
+    components: repoRelativePathsSchema.optional(),
+    outFile: repoRelativePathSchema.optional(),
+    framework: z.enum(["react", "vue", "svelte"]).optional(),
+    figmaFile: z.string().url().optional(),
+    figmaToken: z.string().optional(),
+    screenshots: z.object({}).passthrough().optional(),
+    service: z.object({}).passthrough().optional(),
+    registry: z.object({}).passthrough().optional(),
+    tokens: tokenConfigSchema.optional(),
+    snippets: z
+      .object({
+        mode: z.enum(["warn", "error"]).optional(),
+        scope: z.enum(["snippet", "snippet+render"]).optional(),
+        requireFullSnippet: z.boolean().optional(),
+        allowedExternalModules: z.array(z.string().min(1)).optional(),
+      })
+      .optional(),
+    performance: z
+      .union([
+        z.enum(["strict", "standard", "relaxed"]),
+        z.object({
+          preset: z.enum(["strict", "standard", "relaxed"]).optional(),
+          budgets: z
+            .object({
+              bundleSize: z.number().positive().optional(),
+            })
+            .optional(),
+        }),
+      ])
+      .optional(),
+    topology: topologySchema.optional(),
+    govern: governanceConfigSchema.optional(),
+    inspect: z
+      .object({
+        localCanonical: z
+          .record(
+            z.string().min(1),
+            z.object({
+              importPath: z.string().min(1),
+              resolves: z
+                .array(
+                  z.object({
+                    tag: z.string().min(1),
+                    role: z.string().min(1).optional(),
+                    inputType: z.string().min(1).optional(),
+                  })
+                )
+                .min(1),
+            })
+          )
           .optional(),
-      }),
-    ])
-    .optional(),
-  storybook: z
-    .object({
-      exclude: z.array(z.string()).optional(),
-      include: z.array(z.string()).optional(),
-      excludeDeprecated: z.boolean().optional(),
-      excludeTests: z.boolean().optional(),
-      excludeSvgIcons: z.boolean().optional(),
-      excludeSubComponents: z.boolean().optional(),
-    })
-    .optional(),
-  topology: topologySchema.optional(),
-  govern: governanceConfigSchema.optional(),
-  inspect: z
-    .object({
-      localCanonical: z
-        .record(
-          z.string().min(1),
-          z.object({
-            importPath: z.string().min(1),
-            resolves: z
-              .array(
-                z.object({
-                  tag: z.string().min(1),
-                  role: z.string().min(1).optional(),
-                  inputType: z.string().min(1).optional(),
-                })
-              )
-              .min(1),
-          })
-        )
-        .optional(),
-    })
-    .optional(),
-  recognizedClassHelpers: z.array(z.string().min(1)).optional(),
-  identity: z
-    .object({
-      decisions: z
-        .array(
-          z.object({
-            component: z.string().min(1),
-            kind: z.enum(["sanction", "reject", "dismiss"]),
-            canonicalTarget: z.string().min(1).optional(),
-            reason: z.string().optional(),
-            decisionId: z.string().min(1).optional(),
-          })
-        )
-        .optional(),
-    })
-    .optional(),
-});
+      })
+      .optional(),
+    recognizedClassHelpers: z.array(z.string().min(1)).optional(),
+    identity: z
+      .object({
+        decisions: z
+          .array(
+            z.object({
+              component: z.string().min(1),
+              kind: z.enum(["sanction", "reject", "dismiss"]),
+              canonicalTarget: z.string().min(1).optional(),
+              reason: z.string().optional(),
+              decisionId: z.string().min(1).optional(),
+            })
+          )
+          .optional(),
+      })
+      .optional(),
+  });
 
 // ---------------------------------------------------------------------------
 // v2 Schemas — alongside v1 (non-breaking)
@@ -415,10 +434,13 @@ export const compositionMetadataSchema = z.object({
  * Schema for v2 extended provenance tracking
  */
 export const fragmentProvenanceSchema = z.object({
-  source: z.enum(["storybook", "manual", "ai", "scan"]),
+  source: z.enum(fragmentSourceValues),
   sourceFile: z.string().optional(),
   confidence: z.number().min(0).max(1).optional(),
-  timestamp: z.string().datetime().optional(),
+  verified: z.boolean().optional(),
+  frameworkSupport: z.enum(["native", "manual-only"]).optional(),
+  sourceHash: z.string().optional(),
+  timestamp: z.string().datetime({ offset: true }).optional(),
   autoFields: z.array(z.string()).optional(),
   humanFields: z.array(z.string()).optional(),
 });
@@ -439,21 +461,179 @@ export const fragmentDefinitionV2Schema = z.object({
   _provenance: fragmentProvenanceSchema.optional(),
 });
 
-export const governedFragmentDefinitionSchema = z.object({
-  component: z.any(),
-  meta: fragmentMetaSchema,
-  guidance: fragmentUsageSchema,
-  props: z.record(propDefinitionSchema).optional(),
-  relations: z.array(componentRelationSchema).optional(),
-  examples: z.array(fragmentVariantSchema).optional(),
-  composition: compositionMetadataSchema.optional(),
+export const governedFragmentDefinitionSchema = z
+  .object({
+    component: z.any(),
+    meta: fragmentMetaSchema,
+    guidance: fragmentUsageSchema,
+    props: z.record(propDefinitionSchema).optional(),
+    relations: z.array(componentRelationSchema).optional(),
+    examples: z.array(fragmentVariantSchema).optional(),
+    composition: compositionMetadataSchema.optional(),
+    contract: fragmentContractSchema.optional(),
+    _provenance: fragmentProvenanceSchema.optional(),
+    govern: z.function().optional(),
+    governance: z.array(componentGovernanceRecordSchema).optional(),
+  })
+  .superRefine((def, ctx) => {
+    if (def.govern === undefined && def.governance === undefined) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: "Governed definitions require `govern` or `governance`",
+        path: ["govern"],
+      });
+    }
+  });
+
+const fragmentRenderSchema = z.custom<FragmentStateV3["render"]>(
+  (value) => value !== undefined && typeof value !== "string",
+  "Expected JSX/render value, not a code string"
+);
+
+export const fragmentMetaV3Schema = z
+  .object({
+    name: z.string().min(1),
+    purpose: z.string().min(1),
+    category: z.string().min(1),
+    status: z.enum(["stable", "beta", "deprecated", "experimental"]).optional(),
+    aliases: z.array(z.string().min(1)).optional(),
+    tags: z.array(z.string()).optional(),
+    since: z.string().optional(),
+    dependencies: z
+      .array(
+        z
+          .object({
+            name: z.string().min(1),
+            version: z.string().min(1),
+            reason: z.string().optional(),
+          })
+          .strict()
+      )
+      .optional(),
+    figma: z.string().url().optional(),
+    figmaProps: z.record(figmaPropMappingSchema).optional(),
+  })
+  .strict() as unknown as z.ZodType<FragmentMetaV3>;
+
+export const fragmentStateV3Schema: z.ZodType<FragmentStateV3> = z
+  .object({
+    render: fragmentRenderSchema,
+    note: z.string().optional(),
+    canonical: z.boolean().optional(),
+  })
+  .strict();
+
+export const fragmentDontExampleV3Schema: z.ZodType<FragmentDontExampleV3> = z
+  .object({
+    reason: z.string().min(1),
+    bad: z.string().min(1),
+    good: fragmentRenderSchema,
+  })
+  .strict();
+
+export const fragmentGuidanceV3Schema: z.ZodType<FragmentGuidanceV3> = z
+  .object({
+    when: z.array(z.string()),
+    whenNot: z.array(z.string()),
+    choose: z.record(z.string()).optional(),
+    dont: z.array(fragmentDontExampleV3Schema).optional(),
+    guidelines: z.array(z.string()).optional(),
+    accessibility: z.array(z.string()).optional(),
+  })
+  .strict();
+
+export const fragmentMatrixV3Schema: z.ZodType<FragmentMatrixV3> = z
+  .object({
+    axes: z.record(z.union([z.literal("auto"), z.array(z.string().min(1)).readonly()])).optional(),
+    forced: z.array(z.string().min(1)).optional(),
+    worstCase: z.record(z.unknown()).optional(),
+  })
+  .strict();
+
+export const fragmentPreviewV3Schema: z.ZodType<FragmentPreviewV3> = z
+  .object({
+    providers: z.array(z.unknown()).optional(),
+    dynamicRegions: z.array(z.string()).optional(),
+  })
+  .strict();
+
+export const fragmentDesignV3Schema: z.ZodType<FragmentDesignV3> = z
+  .object({
+    figmaNode: z.string().min(1).optional(),
+  })
+  .strict();
+
+/**
+ * Annotate-only prop entries. Forbidden keys (`type`, `default`, `values`,
+ * `required`) redefine extracted truth and are rejected.
+ */
+export const propAnnotationSchema: z.ZodType<PropAnnotation> = z
+  .object({
+    description: z.string().optional(),
+    controlType: z
+      .enum([
+        "text",
+        "number",
+        "range",
+        "boolean",
+        "select",
+        "multi-select",
+        "radio",
+        "inline-radio",
+        "check",
+        "inline-check",
+        "object",
+        "file",
+        "color",
+        "date",
+      ])
+      .optional(),
+    controlOptions: z.record(z.unknown()).optional(),
+    visibility: z.enum(["public", "internal", "hidden"]).optional(),
+    constraints: z.array(z.string()).optional(),
+  })
+  .strict();
+
+export const fragmentAnnotationsV3Schema: z.ZodType<FragmentAnnotationsV3> = z
+  .object({
+    notes: z.array(z.string()).optional(),
+    review: z.array(z.string()).optional(),
+  })
+  .passthrough();
+
+/**
+ * Schema for the v3 definition body (second argument). Arity — not keys —
+ * discriminates v3 at the call site; this schema never accepts authored `code`.
+ */
+const fragmentDefinitionV3BodyShape = {
+  meta: fragmentMetaV3Schema,
+  states: z.record(fragmentStateV3Schema).refine((states) => Object.keys(states).length > 0, {
+    message: "At least one state is required",
+  }),
+  guidance: fragmentGuidanceV3Schema,
+  matrix: fragmentMatrixV3Schema.optional(),
+  preview: fragmentPreviewV3Schema.optional(),
+  design: fragmentDesignV3Schema.optional(),
+  annotations: fragmentAnnotationsV3Schema.optional(),
+  props: z.record(propAnnotationSchema).optional(),
+  relations: z.array(componentRelationSchema.strict()).optional(),
+  composition: compositionMetadataSchema.strict().optional(),
   contract: fragmentContractSchema.optional(),
   _provenance: fragmentProvenanceSchema.optional(),
   govern: z.function().optional(),
   governance: z.array(componentGovernanceRecordSchema).optional(),
-});
+};
 
-/**
- * @deprecated Use blockDefinitionSchema instead
- */
-export const recipeDefinitionSchema = blockDefinitionSchema;
+export const fragmentDefinitionV3BodySchema = z
+  .object(fragmentDefinitionV3BodyShape)
+  .strict() as unknown as z.ZodType<FragmentDefinitionV3Body<unknown>>;
+
+export const fragmentDefinitionV3Schema = z
+  .object({
+    ...fragmentDefinitionV3BodyShape,
+    component: z.unknown().refine((component) => component !== undefined, {
+      message: "Component is required",
+    }),
+    governance: z.array(componentGovernanceRecordSchema),
+  })
+  .strict() as unknown as z.ZodType<FragmentDefinitionV3<unknown>>;

package/src/schemas/index.ts

@@ -347,7 +347,7 @@ export const agentErrorEnvelopeSchema = z.object({
   }),
   provenance: agentRunProvenanceSchema.optional(),
   verdict: agentRunVerdictSchema.optional(),
-  cloudReport: z.enum(["reported", "failed", "skipped"]).optional(),
+  cloudReport: z.enum(["accepted", "reported", "failed", "skipped"]).optional(),
   notices: z.array(z.string()).optional(),
 });
 export type AgentErrorEnvelope = z.infer<typeof agentErrorEnvelopeSchema>;