@ogygie/core 0.1.0

package/src/manifest-gateway.ts

@@ -0,0 +1,392 @@
+/**
+ * @intent GENERIC manifest-driven gateway factory (D27), framework side: this
+ * module knows ZERO product vocabulary (D10 amended — generic tooling lives in
+ * the core), and the vocabulary test next to it proves it. It derives a pure
+ * relay from an Ogygie manifest: every declared route becomes a typed relay to
+ * the upstream api, nothing else is reachable. Boot REFUSES an incoherent
+ * manifest (GATEWAY_MANIFEST_INVALID) — a boot refusal beats a lying relay.
+ *
+ * The consuming app owns everything product-aware: the schema registry, the
+ * env contract, the server entry point, and the closed passthrough list.
+ * Usage: see packages/ogygie-core/README.md.
+ *
+ * Input validation (2nd barrier, no transitive trust — the api revalidates):
+ * the declared input schema validates the JSON body on POST/PUT/PATCH, and
+ * the merged { ...query, ...params } object on GET/DELETE — the exact slots
+ * the api binds those schemas to (body / querystring / params).
+ *
+ * Relay purity: upstream status and body are forwarded byte-for-byte
+ * (OgygieError included, Set-Cookie retransmitted integrally). The gateway
+ * only OWNS the transverse security headers (CSP, HSTS…): those are stripped
+ * from upstream responses so the strict policy set HERE is authoritative.
+ */
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { randomUUID } from "node:crypto";
+import Fastify, { type FastifyReply, type FastifyRequest } from "fastify";
+import helmet from "@fastify/helmet";
+import rateLimit from "@fastify/rate-limit";
+import fastifyStatic from "@fastify/static";
+import type { z } from "zod";
+import { OgygieManifestSchema } from "./manifest.schema.js";
+import { ogygieError, throwOgygieError } from "./error.schema.js";
+
+export interface ManifestGatewayOptions {
+  upstreamBaseUrl: string;
+  /** Declared input/output schemas, keyed by their exported name. */
+  schemas: Record<string, z.ZodType>;
+  /** Front build to serve (SPA fallback on index.html); nothing served when absent. */
+  staticRoot?: string;
+  rateLimit?: { max: number; timeWindow: string };
+  timeoutMs: number;
+  csp: { nonce: boolean };
+  /** Path prefixes relayed WITHOUT contract validation (e.g. an auth
+   * catch-all owned by the upstream, absent from the manifest by nature). */
+  passthroughPrefixes?: string[];
+}
+
+export interface GatewayRouteInventoryEntry {
+  method: "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
+  path: string;
+  schemaInput: string;
+}
+
+declare module "fastify" {
+  interface FastifyInstance {
+    /** Mounted relays, in manifest order — the startup log and the tests read it. */
+    gatewayRoutes: ReadonlyArray<GatewayRouteInventoryEntry>;
+  }
+}
+
+const METHODS_WITH_BODY = new Set(["POST", "PUT", "PATCH"]);
+
+/** Hop-by-hop or recomputed headers, never forwarded upstream. */
+const SKIPPED_REQUEST_HEADERS = new Set([
+  "host",
+  "connection",
+  "content-length",
+  "transfer-encoding",
+  "accept-encoding",
+  "keep-alive",
+  "expect",
+  "upgrade",
+]);
+
+/** Not relayed back: hop-by-hop headers, recomputed lengths, and the
+ * security headers the gateway is the single owner of (spec: posed HERE,
+ * once for the whole product — an upstream copy must not override them). */
+const SKIPPED_RESPONSE_HEADERS = new Set([
+  "connection",
+  "keep-alive",
+  "transfer-encoding",
+  "content-length",
+  "content-encoding",
+  "set-cookie",
+  "content-security-policy",
+  "cross-origin-embedder-policy",
+  "cross-origin-opener-policy",
+  "cross-origin-resource-policy",
+  "origin-agent-cluster",
+  "permissions-policy",
+  "referrer-policy",
+  "strict-transport-security",
+  "x-content-type-options",
+  "x-dns-prefetch-control",
+  "x-download-options",
+  "x-frame-options",
+  "x-permitted-cross-domain-policies",
+  "x-xss-protection",
+]);
+
+/** Manifest route paths are plain /api segments with :params — anything else
+ * (regex, wildcard, spaces…) is a malformed declaration, refused at boot. */
+const WELL_FORMED_ROUTE_PATH = /^\/api(\/(:?[a-zA-Z0-9_-]+))+$/;
+
+function refuseBoot(cause: string): never {
+  throwOgygieError(
+    {
+      code: "GATEWAY_MANIFEST_INVALID",
+      message: "Gateway boot refused: the manifest cannot be derived into relays.",
+      file: "ogygie.manifest.json",
+      cause,
+      suggestedFix:
+        "Fix the manifest (or register the missing schema in the gateway's schema registry), then restart — a boot refusal beats a lying relay.",
+    },
+    500,
+  );
+}
+
+export async function createManifestGateway(
+  manifest: unknown,
+  options: ManifestGatewayOptions,
+) {
+  const parsedManifest = OgygieManifestSchema.safeParse(manifest);
+  if (!parsedManifest.success) {
+    refuseBoot(
+      parsedManifest.error.issues
+        .map((issue) => `${issue.path.join(".")}: ${issue.message}`)
+        .join(" ; "),
+    );
+  }
+
+  const inventory: GatewayRouteInventoryEntry[] = [];
+  const mounted = new Set<string>();
+  for (const feature of parsedManifest.data.features) {
+    for (const route of feature.routes) {
+      if (!WELL_FORMED_ROUTE_PATH.test(route.path)) {
+        refuseBoot(`feature "${feature.name}": route path "${route.path}" is malformed`);
+      }
+      for (const schemaName of [route.schemaInput, route.schemaOutput]) {
+        if (options.schemas[schemaName] === undefined) {
+          refuseBoot(
+            `feature "${feature.name}": route ${route.method} ${route.path} declares schema "${schemaName}" which is not in the schema registry`,
+          );
+        }
+      }
+      const key = `${route.method} ${route.path}`;
+      if (mounted.has(key)) {
+        refuseBoot(`route ${key} is declared twice`);
+      }
+      mounted.add(key);
+      inventory.push({
+        method: route.method,
+        path: route.path,
+        schemaInput: route.schemaInput,
+      });
+    }
+  }
+
+  const app = Fastify({ logger: false });
+  app.decorate("gatewayRoutes", inventory);
+
+  // Bodies are kept RAW (string/buffer): the gateway validates a parsed COPY
+  // but relays the original bytes — it never re-serializes a payload.
+  app.removeAllContentTypeParsers();
+  app.addContentTypeParser(
+    "application/json",
+    { parseAs: "string" },
+    (_request, body, done) => done(null, body),
+  );
+  app.addContentTypeParser("*", { parseAs: "buffer" }, (_request, body, done) =>
+    done(null, body),
+  );
+
+  await app.register(helmet, {
+    // Strict CSP, no 'unsafe-inline' anywhere; per-request nonces cover the
+    // scripts the front build may inline (spec §Comportements).
+    enableCSPNonces: options.csp.nonce,
+    contentSecurityPolicy: {
+      useDefaults: false,
+      directives: {
+        "default-src": ["'self'"],
+        "script-src": ["'self'"],
+        "style-src": ["'self'"],
+        "img-src": ["'self'", "data:"],
+        "font-src": ["'self'"],
+        "connect-src": ["'self'"],
+        "object-src": ["'none'"],
+        "base-uri": ["'self'"],
+        "form-action": ["'self'"],
+        "frame-ancestors": ["'none'"],
+      },
+    },
+  });
+  // Helmet does not cover Permissions-Policy; posed here once (spec).
+  app.addHook("onSend", async (_request, reply) => {
+    reply.header("permissions-policy", "camera=(), microphone=(), geolocation=()");
+  });
+  await app.register(rateLimit, options.rateLimit ?? { max: 300, timeWindow: "1 minute" });
+
+  async function relay(request: FastifyRequest, reply: FastifyReply) {
+    const incomingId = request.headers["x-request-id"];
+    const requestId = typeof incomingId === "string" ? incomingId : randomUUID();
+    const headers: Record<string, string> = {};
+    for (const [name, value] of Object.entries(request.headers)) {
+      if (SKIPPED_REQUEST_HEADERS.has(name) || value === undefined) continue;
+      headers[name] = Array.isArray(value) ? value.join(", ") : value;
+    }
+    headers["x-request-id"] = requestId;
+    reply.header("x-request-id", requestId);
+
+    const body =
+      METHODS_WITH_BODY.has(request.method) && request.body !== undefined
+        ? (request.body as string | Buffer)
+        : undefined;
+
+    let upstreamResponse: Response;
+    try {
+      upstreamResponse = await fetch(
+        new URL(request.raw.url ?? request.url, options.upstreamBaseUrl),
+        {
+          method: request.method,
+          headers,
+          ...(body === undefined ? {} : { body }),
+          redirect: "manual",
+          signal: AbortSignal.timeout(options.timeoutMs),
+        },
+      );
+    } catch (error) {
+      // No internal detail leaks: neither the private upstream URL nor a stack.
+      const timedOut = error instanceof Error && error.name === "TimeoutError";
+      return reply.status(timedOut ? 504 : 502).send(
+        ogygieError({
+          code: timedOut ? "GATEWAY_UPSTREAM_TIMEOUT" : "GATEWAY_UPSTREAM_UNAVAILABLE",
+          message: timedOut
+            ? "The upstream api did not answer within the gateway timeout."
+            : "The upstream api is unreachable from the gateway.",
+          file: null,
+          cause: timedOut
+            ? `no upstream response within ${options.timeoutMs} ms`
+            : "upstream connection failed",
+          suggestedFix:
+            "Check that the api service is up and reachable on the private network, then retry.",
+        }),
+      );
+    }
+
+    reply.status(upstreamResponse.status);
+    upstreamResponse.headers.forEach((value, name) => {
+      if (!SKIPPED_RESPONSE_HEADERS.has(name)) reply.header(name, value);
+    });
+    const setCookies = upstreamResponse.headers.getSetCookie();
+    if (setCookies.length > 0) reply.header("set-cookie", setCookies);
+    return reply.send(Buffer.from(await upstreamResponse.arrayBuffer()));
+  }
+
+  function contractViolation(reply: FastifyReply, cause: string) {
+    // Same code and semantics as the api's own handler — emitted BY the
+    // gateway, before any upstream call (invalid traffic never reaches the
+    // private network).
+    return reply.status(400).send(
+      ogygieError({
+        code: "CONTRACT_VALIDATION_FAILED",
+        message: "The request does not satisfy the route's declared input contract.",
+        file: null,
+        cause,
+        suggestedFix: "Fix the listed fields to match the declared Zod input schema.",
+      }),
+    );
+  }
+
+  for (const route of inventory) {
+    const schema = options.schemas[route.schemaInput];
+    if (schema === undefined) continue; // unreachable — boot already refused
+    app.route({
+      method: route.method,
+      url: route.path,
+      handler: async (request, reply) => {
+        let input: unknown;
+        if (METHODS_WITH_BODY.has(route.method)) {
+          const raw = request.body;
+          if (raw === undefined || raw === null || raw === "") {
+            input = {};
+          } else if (typeof raw === "string") {
+            try {
+              input = JSON.parse(raw);
+            } catch {
+              return contractViolation(reply, "request body is not valid JSON");
+            }
+          } else {
+            return contractViolation(reply, "request body is not JSON");
+          }
+        } else {
+          input = { ...(request.query as object), ...(request.params as object) };
+        }
+        const parsed = schema.safeParse(input);
+        if (!parsed.success) {
+          return contractViolation(
+            reply,
+            parsed.error.issues
+              .map((issue) => `${issue.path.join(".") || "(root)"}: ${issue.message}`)
+              .join(" ; "),
+          );
+        }
+        return relay(request, reply);
+      },
+    });
+  }
+
+  for (const prefix of options.passthroughPrefixes ?? []) {
+    app.route({
+      method: ["GET", "POST", "PUT", "PATCH", "DELETE"],
+      url: `${prefix.replace(/\/$/, "")}/*`,
+      handler: relay,
+    });
+  }
+
+  if (options.staticRoot !== undefined) {
+    await app.register(fastifyStatic, {
+      root: options.staticRoot,
+      wildcard: true,
+      index: false,
+    });
+  }
+
+  // index.html is read once and cached: the build is immutable while running.
+  let indexHtmlCache: string | null = null;
+  function readIndexHtml(staticRoot: string): string | null {
+    if (indexHtmlCache === null) {
+      try {
+        indexHtmlCache = readFileSync(join(staticRoot, "index.html"), "utf8");
+      } catch {
+        return null;
+      }
+    }
+    return indexHtmlCache;
+  }
+
+  /**
+   * The SPA shell, with the per-request CSP nonce stamped on every script tag.
+   * Returns false when there is no front to serve, so the caller falls through
+   * to the structured 404 instead of an empty page.
+   */
+  function sendSpaShell(reply: FastifyReply): boolean {
+    const staticRoot = options.staticRoot;
+    if (staticRoot === undefined) return false;
+    const indexHtml = readIndexHtml(staticRoot);
+    if (indexHtml === null) return false;
+    const html = options.csp.nonce
+      ? indexHtml.replaceAll("<script", `<script nonce="${reply.cspNonce.script}"`)
+      : indexHtml;
+    reply.type("text/html; charset=utf-8").send(html);
+    return true;
+  }
+
+  // The ROOT is the product's entry URL, and it is NOT a not-found: the static
+  // plugin owns "/" (wildcard, index disabled) and would answer 403 on the
+  // directory, so the shell is served explicitly here — same nonce path as the
+  // client-side routes below.
+  if (options.staticRoot !== undefined) {
+    app.route({
+      method: ["GET", "HEAD"],
+      url: "/",
+      handler: async (_request, reply) => {
+        if (!sendSpaShell(reply)) {
+          return reply.callNotFound();
+        }
+        return reply;
+      },
+    });
+  }
+
+  app.setNotFoundHandler((request, reply) => {
+    const isReadForHtml = request.method === "GET" || request.method === "HEAD";
+    if (!request.url.startsWith("/api/") && isReadForHtml && sendSpaShell(reply)) {
+      // SPA fallback: every client-side route serves the shell.
+      return reply;
+    }
+    return reply.status(404).send(
+      ogygieError({
+        code: "GATEWAY_ROUTE_UNKNOWN",
+        message: "No declared route matches this request.",
+        file: null,
+        cause: `${request.method} ${request.url} is not declared in the manifest`,
+        suggestedFix:
+          "Declare the route in ogygie.manifest.json — an undeclared route is unreachable by design (D27).",
+      }),
+    );
+  });
+
+  await app.ready();
+  return app;
+}

package/src/manifest.schema.test.ts

@@ -0,0 +1,255 @@
+/**
+ * @intent Mutation tests of the manifest front-feature extension (D22: the
+ * gate evolution is born with its negative tests). The api-feature path is
+ * already covered end-to-end by verify-manifest in CI.
+ */
+import { describe, expect, it } from "vitest";
+import { OgygieManifestSchema } from "./manifest.schema.js";
+
+function manifestWithFeature(feature: Record<string, unknown>) {
+  return {
+    version: 1,
+    product: { name: "acme", description: "SaaS générique servant de fixture aux tests du manifeste." },
+    apps: [
+      { name: "api", path: "apps/api", type: "api", entryPoint: "apps/api/src/server.ts" },
+      { name: "web", path: "apps/web", type: "front", entryPoint: "apps/web/src/main.tsx" },
+    ],
+    features: [
+      {
+        name: "web-shell",
+        intent: "Bootstrap du front : patterns canoniques, auth, écran de preuve.",
+        folder: "src",
+        spec: "specs/web-shell.spec.md",
+        routes: [],
+        dbTables: [],
+        dependsOn: [],
+        status: "delivered",
+        ...feature,
+      },
+    ],
+    conventions: { agentsMd: "AGENTS.md", failuresMd: "FAILURES.md", specsFolder: "specs/" },
+  };
+}
+
+describe("manifest — features front", () => {
+  it("une feature front valide (app: web, routes/dbTables vides) est acceptée", () => {
+    const parsed = OgygieManifestSchema.safeParse(manifestWithFeature({ app: "web" }));
+    expect(parsed.success).toBe(true);
+  });
+
+  it("MUTATION : app inconnu (typo) est refusé", () => {
+    const parsed = OgygieManifestSchema.safeParse(manifestWithFeature({ app: "wbe" }));
+    expect(parsed.success).toBe(false);
+  });
+
+  it("MUTATION : une feature front qui déclare une route HTTP est refusée (les routes appartiennent à l'api)", () => {
+    const parsed = OgygieManifestSchema.safeParse(
+      manifestWithFeature({
+        app: "web",
+        routes: [
+          {
+            method: "GET",
+            path: "/api/orders",
+            description: "duplication interdite de la route api",
+            schemaInput: "ListOrdersInputSchema",
+            schemaOutput: "ListOrdersOutputSchema",
+          },
+        ],
+      }),
+    );
+    expect(parsed.success).toBe(false);
+  });
+
+  it("MUTATION : une feature front qui déclare une table DB est refusée", () => {
+    const parsed = OgygieManifestSchema.safeParse(
+      manifestWithFeature({ app: "web", dbTables: ["orders"] }),
+    );
+    expect(parsed.success).toBe(false);
+  });
+
+  it("sans champ app, une feature reste une feature api (compatibilité intégrale)", () => {
+    const parsed = OgygieManifestSchema.safeParse(manifestWithFeature({}));
+    expect(parsed.success).toBe(true);
+  });
+});
+
+// Front-derivation extension (spec front-derivation): a mutation route may
+// declare the cache roots it stales beyond its own — read by the derived
+// client, verified here: a target matching nothing is a typo that would
+// silently never invalidate anything.
+function manifestWithApiRoutes(routes: ReadonlyArray<Record<string, unknown>>) {
+  return manifestWithFeature({
+    name: "order-log",
+    intent: "Relevés append-only, valeur courante calculée jamais stockée.",
+    folder: "src/features/order-log",
+    spec: "specs/order-log.spec.md",
+    routes,
+  });
+}
+
+const createRecordRoute = {
+  method: "POST",
+  path: "/api/records",
+  description: "Enregistre un relevé constaté (append-only).",
+  schemaInput: "CreateRecordInputSchema",
+  schemaOutput: "CreateRecordOutputSchema",
+};
+const listArchiveRoute = {
+  method: "GET",
+  path: "/api/record-archive",
+  description: "Vue archive avec valeur courante calculée ou null.",
+  schemaInput: "ListRecordArchiveInputSchema",
+  schemaOutput: "ListRecordArchiveOutputSchema",
+};
+
+describe("manifest — invalidations croisées des routes (spec front-derivation)", () => {
+  it("une route sans invalidates reste acceptée (champ optionnel, élargissement libre)", () => {
+    const parsed = OgygieManifestSchema.safeParse(
+      manifestWithApiRoutes([createRecordRoute]),
+    );
+    expect(parsed.success).toBe(true);
+  });
+
+  it("invalidates visant la racine d'une route existante est accepté", () => {
+    const parsed = OgygieManifestSchema.safeParse(
+      manifestWithApiRoutes([
+        { ...createRecordRoute, invalidates: ["record-archive"] },
+        listArchiveRoute,
+      ]),
+    );
+    expect(parsed.success).toBe(true);
+  });
+
+  it("invalidates visant un nom de feature existant est accepté", () => {
+    const parsed = OgygieManifestSchema.safeParse(
+      manifestWithApiRoutes([
+        { ...createRecordRoute, invalidates: ["order-log"] },
+      ]),
+    );
+    expect(parsed.success).toBe(true);
+  });
+
+  it("MUTATION : invalidates visant une cible inconnue (typo) est refusé", () => {
+    const parsed = OgygieManifestSchema.safeParse(
+      manifestWithApiRoutes([
+        { ...createRecordRoute, invalidates: ["record-archivee"] },
+        listArchiveRoute,
+      ]),
+    );
+    expect(parsed.success).toBe(false);
+  });
+});
+
+// Gateway extension (D27): the gateway app type exists, and
+// a gateway feature — like a front one — OWNS no routes and no tables (it
+// RELAYS the api's declared routes, it never declares its own).
+function manifestWithGatewayFeature(feature: Record<string, unknown>) {
+  const base = manifestWithFeature({
+    name: "edge-gateway",
+    intent: "Passerelle publique dérivée du manifeste : relais typé des routes déclarées.",
+    app: "gateway",
+    spec: "specs/edge-gateway.spec.md",
+    ...feature,
+  });
+  base.apps.push({
+    name: "gateway",
+    path: "apps/gateway",
+    type: "gateway",
+    entryPoint: "apps/gateway/src/server.ts",
+  });
+  return base;
+}
+
+describe("manifest — app gateway (D27)", () => {
+  it("une feature gateway valide (app: gateway, routes/dbTables vides) est acceptée", () => {
+    const parsed = OgygieManifestSchema.safeParse(manifestWithGatewayFeature({}));
+    expect(parsed.success).toBe(true);
+  });
+
+  it("MUTATION : un type d'app inconnu (typo « gatway ») est refusé", () => {
+    const manifest = manifestWithGatewayFeature({});
+    const gatewayApp = manifest.apps.find((app) => app.name === "gateway");
+    if (gatewayApp !== undefined) gatewayApp.type = "gatway";
+    expect(OgygieManifestSchema.safeParse(manifest).success).toBe(false);
+  });
+
+  it("MUTATION : une feature gateway qui déclare une route HTTP est refusée (elle relaie, elle ne possède pas)", () => {
+    const parsed = OgygieManifestSchema.safeParse(
+      manifestWithGatewayFeature({
+        routes: [
+          {
+            method: "GET",
+            path: "/api/orders",
+            description: "duplication interdite de la route api",
+            schemaInput: "ListOrdersInputSchema",
+            schemaOutput: "ListOrdersOutputSchema",
+          },
+        ],
+      }),
+    );
+    expect(parsed.success).toBe(false);
+  });
+});
+
+// Standalone-repo extension (spec ogygie-standalone-repo): a consumer manifest
+// pins its framework version (`ogygieVersion`), and the framework repo's own
+// manifest describes its published packages, templates and governed-files
+// module (`framework`) so B1's discoverability holds without exploration.
+describe("manifest — ogygieVersion et bloc framework (spec ogygie-standalone-repo)", () => {
+  it("un manifeste consommateur avec ogygieVersion x.y.z est accepté", () => {
+    const manifest = { ...manifestWithFeature({}), ogygieVersion: "0.1.0" };
+    expect(OgygieManifestSchema.safeParse(manifest).success).toBe(true);
+  });
+
+  it("MUTATION : un ogygieVersion non x.y.z (« 0.1 ») est refusé", () => {
+    const manifest = { ...manifestWithFeature({}), ogygieVersion: "0.1" };
+    expect(OgygieManifestSchema.safeParse(manifest).success).toBe(false);
+  });
+
+  it("MUTATION : un ogygieVersion avec préfixe de plage (« ^0.1.0 ») est refusé", () => {
+    const manifest = { ...manifestWithFeature({}), ogygieVersion: "^0.1.0" };
+    expect(OgygieManifestSchema.safeParse(manifest).success).toBe(false);
+  });
+
+  it("le bloc framework complet (packages, templates, governedFiles) est accepté", () => {
+    const manifest = {
+      ...manifestWithFeature({}),
+      framework: {
+        packages: [
+          {
+            name: "@ogygie/core",
+            path: "packages/ogygie-core",
+            intent: "Schémas, erreurs et outillage génériques du framework.",
+          },
+        ],
+        templates: { project: "templates/project", feature: "templates/feature" },
+        governedFiles: "packages/ogygie-cli/src/governed-files.ts",
+      },
+    };
+    expect(OgygieManifestSchema.safeParse(manifest).success).toBe(true);
+  });
+
+  it("MUTATION : un bloc framework sans governedFiles est refusé (la liste gouvernée doit être localisable)", () => {
+    const manifest = {
+      ...manifestWithFeature({}),
+      framework: {
+        packages: [],
+        templates: { project: "templates/project", feature: "templates/feature" },
+      },
+    };
+    expect(OgygieManifestSchema.safeParse(manifest).success).toBe(false);
+  });
+
+  it("les deux champs restent optionnels (compatibilité intégrale des manifestes existants)", () => {
+    expect(OgygieManifestSchema.safeParse(manifestWithFeature({})).success).toBe(true);
+  });
+});
+
+describe("manifest — app gateway, suite (D27)", () => {
+  it("MUTATION (bis) : une feature gateway qui déclare une table DB est refusée", () => {
+    const parsed = OgygieManifestSchema.safeParse(
+      manifestWithGatewayFeature({ dbTables: ["orders"] }),
+    );
+    expect(parsed.success).toBe(false);
+  });
+});