@hasna/instructions 0.4.20 → 0.4.21

package/dist/server/index.js

@@ -2331,6 +2331,54 @@ async function closeCloud() {
 
 // src/storage/cloud-store.ts
 import { randomUUID } from "crypto";
+
+// src/lib/compact-output.ts
+var DEFAULT_LIST_LIMIT = 20;
+var MAX_LIST_LIMIT = 100;
+function parseLimit(value, fallback = DEFAULT_LIST_LIMIT, max = MAX_LIST_LIMIT) {
+  const parsed = typeof value === "number" ? value : Number.parseInt(String(value ?? ""), 10);
+  if (!Number.isFinite(parsed) || parsed <= 0)
+    return fallback;
+  return Math.min(Math.floor(parsed), max);
+}
+function parseCursor(value) {
+  const parsed = typeof value === "number" ? value : Number.parseInt(String(value ?? ""), 10);
+  if (!Number.isFinite(parsed) || parsed < 0)
+    return 0;
+  return Math.floor(parsed);
+}
+
+// src/lib/bounded-read.ts
+function normalizeBoundedReadOptions(options = {}) {
+  return {
+    limit: parseLimit(options.limit, DEFAULT_LIST_LIMIT, MAX_LIST_LIMIT),
+    cursor: parseCursor(options.cursor)
+  };
+}
+function boundedReadPage(items, total, options = {}) {
+  const { limit, cursor } = normalizeBoundedReadOptions(options);
+  if (items.length > limit) {
+    throw new Error(`bounded read returned ${items.length} rows for limit ${limit}`);
+  }
+  const consumed = cursor + items.length;
+  const complete = consumed >= total;
+  if (!complete && items.length === 0) {
+    throw new Error(`bounded read did not advance at cursor ${cursor} of ${total}`);
+  }
+  return {
+    items,
+    total,
+    limit,
+    cursor,
+    next_cursor: complete ? null : consumed,
+    has_more: !complete,
+    complete,
+    truncated: false,
+    source_bounded: true
+  };
+}
+
+// src/storage/cloud-store.ts
 function slugify(name) {
   return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
 }
@@ -2560,8 +2608,21 @@ function rowToProfile(row) {
   };
 }
 async function listProfiles(client) {
-  const rows = await client.many("SELECT * FROM profiles ORDER BY name");
-  return rows.map(rowToProfile);
+  const profiles = [];
+  let cursor = 0;
+  while (true) {
+    const page = await listProfilesPage(client, { limit: 100, cursor });
+    profiles.push(...page.items);
+    if (page.complete)
+      return profiles;
+    cursor = page.next_cursor;
+  }
+}
+async function listProfilesPage(client, options = {}) {
+  const normalized = normalizeBoundedReadOptions(options);
+  const count = await client.get("SELECT COUNT(*) AS total FROM profiles");
+  const rows = await client.many("SELECT * FROM profiles ORDER BY name LIMIT $1 OFFSET $2", [normalized.limit, normalized.cursor]);
+  return boundedReadPage(rows.map(rowToProfile), Number(count?.total ?? 0), normalized);
 }
 async function getProfile(client, idOrSlug) {
   const row = await client.get("SELECT * FROM profiles WHERE id = $1 OR slug = $1", [idOrSlug]);
@@ -2570,12 +2631,26 @@ async function getProfile(client, idOrSlug) {
   return rowToProfile(row);
 }
 async function getProfileConfigs(client, idOrSlug) {
+  const configs = [];
+  let cursor = 0;
+  while (true) {
+    const page = await getProfileConfigsPage(client, idOrSlug, { limit: 100, cursor });
+    configs.push(...page.items);
+    if (page.complete)
+      return configs;
+    cursor = page.next_cursor;
+  }
+}
+async function getProfileConfigsPage(client, idOrSlug, options = {}) {
   const profile = await getProfile(client, idOrSlug);
+  const normalized = normalizeBoundedReadOptions(options);
+  const count = await client.get("SELECT COUNT(*) AS total FROM profile_configs WHERE profile_id = $1", [profile.id]);
   const rows = await client.many(`SELECT c.* FROM configs c
        JOIN profile_configs pc ON pc.config_id = c.id
       WHERE pc.profile_id = $1
-      ORDER BY pc.sort_order`, [profile.id]);
-  return rows.map(rowToConfig);
+      ORDER BY pc.sort_order
+      LIMIT $2 OFFSET $3`, [profile.id, normalized.limit, normalized.cursor]);
+  return boundedReadPage(rows.map(rowToConfig), Number(count?.total ?? 0), normalized);
 }
 async function createProfile(client, input) {
   if (!input.name || !input.name.trim())
@@ -2638,22 +2713,46 @@ async function removeConfigFromProfile(client, profileIdOrSlug, configId) {
 function profileHasSelectors(selectors) {
   return (selectors.os?.length ?? 0) > 0 || (selectors.arch?.length ?? 0) > 0 || (selectors.hostnames?.length ?? 0) > 0;
 }
-async function resolveProfileForMachine(client, machine) {
-  const profiles = (await listProfiles(client)).filter((p) => profileHasSelectors(p.selectors));
+async function resolveProfileForMachineRead(client, machine, options = {}) {
+  const { limit } = normalizeBoundedReadOptions(options);
   const host = (machine.hostname ?? "").trim().toLowerCase();
   const os = (machine.os ?? "").trim().toLowerCase();
   const arch = (machine.arch ?? "").trim().toLowerCase();
-  const matches = profiles.filter((p) => {
-    const s = p.selectors;
-    const osOk = !s.os?.length || s.os.some((c) => c.trim().toLowerCase() === os);
-    const archOk = !s.arch?.length || s.arch.some((c) => c.trim().toLowerCase() === arch);
-    const hostOk = !s.hostnames?.length || s.hostnames.some((c) => c.trim().toLowerCase() === host);
-    return osOk && archOk && hostOk;
-  }).map((p) => ({
-    profile: p,
-    score: (p.selectors.hostnames?.length ? 100 : 0) + (p.selectors.os?.length ? 10 : 0) + (p.selectors.arch?.length ? 10 : 0)
-  })).sort((a, b) => b.score - a.score || a.profile.name.localeCompare(b.profile.name));
-  return matches[0]?.profile ?? null;
+  let cursor = 0;
+  let scanned = 0;
+  let total = 0;
+  let selected = null;
+  while (true) {
+    const page = await listProfilesPage(client, { limit, cursor });
+    total = page.total;
+    scanned += page.items.length;
+    for (const p of page.items) {
+      if (!profileHasSelectors(p.selectors))
+        continue;
+      const s = p.selectors;
+      const osOk = !s.os?.length || s.os.some((c) => c.trim().toLowerCase() === os);
+      const archOk = !s.arch?.length || s.arch.some((c) => c.trim().toLowerCase() === arch);
+      const hostOk = !s.hostnames?.length || s.hostnames.some((c) => c.trim().toLowerCase() === host);
+      if (!osOk || !archOk || !hostOk)
+        continue;
+      const score = (p.selectors.hostnames?.length ? 100 : 0) + (p.selectors.os?.length ? 10 : 0) + (p.selectors.arch?.length ? 10 : 0);
+      if (!selected || score > selected.score || score === selected.score && p.name.localeCompare(selected.profile.name) < 0) {
+        selected = { profile: p, score };
+      }
+    }
+    if (page.complete)
+      break;
+    cursor = page.next_cursor;
+  }
+  return {
+    profile: selected?.profile ?? null,
+    scanned,
+    total,
+    batch_limit: limit,
+    source_bounded: true,
+    complete: true,
+    truncated: false
+  };
 }
 function rowToMachine(row) {
   return {
@@ -2698,6 +2797,19 @@ function json(body, status = 200) {
 function errorResponse(status, message, extra) {
   return json({ error: message, ...extra ?? {} }, status);
 }
+function completeLegacyPage(items) {
+  return {
+    items,
+    total: items.length,
+    limit: Math.max(items.length, 1),
+    cursor: 0,
+    next_cursor: null,
+    has_more: false,
+    complete: true,
+    truncated: false,
+    source_bounded: false
+  };
+}
 async function readJson(req) {
   try {
     const text = await req.text();
@@ -2799,8 +2911,15 @@ async function handleV1Request(req, url) {
     if (resource === "profiles") {
       if (!id) {
         if (method === "GET") {
-          const profiles = await listProfiles(client);
-          return json({ profiles, count: profiles.length });
+          if (!url.searchParams.has("limit") && !url.searchParams.has("cursor")) {
+            const profiles = await listProfiles(client);
+            return json({ ...completeLegacyPage(profiles), profiles, count: profiles.length });
+          }
+          const page = await listProfilesPage(client, {
+            limit: url.searchParams.get("limit") ?? undefined,
+            cursor: url.searchParams.get("cursor") ?? undefined
+          });
+          return json({ ...page, profiles: page.items, count: page.items.length });
         }
         if (method === "POST") {
           const body = await readJson(req);
@@ -2818,14 +2937,12 @@ async function handleV1Request(req, url) {
       if (id === "resolve") {
         if (method !== "GET")
           return errorResponse(405, `method ${method} not allowed on /v1/profiles/resolve`);
-        const profile = await resolveProfileForMachine(client, {
+        const resolution = await resolveProfileForMachineRead(client, {
           hostname: url.searchParams.get("hostname") ?? undefined,
           os: url.searchParams.get("os") ?? undefined,
           arch: url.searchParams.get("arch") ?? undefined
-        });
-        if (!profile)
-          return errorResponse(404, "no matching machine-aware profile");
-        return json({ profile });
+        }, { limit: url.searchParams.get("limit") ?? undefined });
+        return json(resolution);
       }
       if (action === "configs") {
         const configId = segments[4] ? decodeURIComponent(segments[4]) : undefined;
@@ -2846,8 +2963,18 @@ async function handleV1Request(req, url) {
         return errorResponse(404, `unknown profile action: ${action}`);
       if (method === "GET") {
         const profile = await getProfile(client, id);
-        const configs = await getProfileConfigs(client, id);
-        return json({ profile: { ...profile, configs } });
+        if (!url.searchParams.has("limit") && !url.searchParams.has("cursor")) {
+          const legacyConfigs = await getProfileConfigs(client, id);
+          return json({
+            profile: { ...profile, configs: legacyConfigs },
+            configs: completeLegacyPage(legacyConfigs)
+          });
+        }
+        const configs = await getProfileConfigsPage(client, id, {
+          limit: url.searchParams.get("limit") ?? undefined,
+          cursor: url.searchParams.get("cursor") ?? undefined
+        });
+        return json({ profile: { ...profile, configs: configs.items }, configs });
       }
       if (method === "PATCH" || method === "PUT") {
         const body = await readJson(req);
@@ -3013,6 +3140,66 @@ function buildV1OpenApiDocument(version = getPackageVersion()) {
             selectors: { type: "object" },
             variables: { type: "object" }
           }
+        },
+        ProfileWithConfigs: {
+          type: "object",
+          properties: {
+            ...profileSchema.properties,
+            configs: { type: "array", items: { $ref: "#/components/schemas/Config" } }
+          }
+        },
+        BoundedProfilePage: {
+          type: "object",
+          required: ["items", "total", "limit", "cursor", "next_cursor", "has_more", "complete", "truncated", "source_bounded"],
+          properties: {
+            profiles: { type: "array", items: { $ref: "#/components/schemas/Profile" } },
+            items: { type: "array", items: { $ref: "#/components/schemas/Profile" } },
+            count: { type: "number" },
+            total: { type: "number" },
+            limit: { type: "number" },
+            cursor: { type: "number" },
+            next_cursor: { type: "number", nullable: true },
+            has_more: { type: "boolean" },
+            complete: { type: "boolean" },
+            truncated: { type: "boolean", const: false },
+            source_bounded: { type: "boolean" }
+          }
+        },
+        BoundedConfigPage: {
+          type: "object",
+          required: ["items", "total", "limit", "cursor", "next_cursor", "has_more", "complete", "truncated", "source_bounded"],
+          properties: {
+            items: { type: "array", items: { $ref: "#/components/schemas/Config" } },
+            total: { type: "number" },
+            limit: { type: "number" },
+            cursor: { type: "number" },
+            next_cursor: { type: "number", nullable: true },
+            has_more: { type: "boolean" },
+            complete: { type: "boolean" },
+            truncated: { type: "boolean", const: false },
+            source_bounded: { type: "boolean" }
+          }
+        },
+        ProfileShowResponse: {
+          type: "object",
+          required: ["profile", "configs"],
+          properties: {
+            profile: { $ref: "#/components/schemas/ProfileWithConfigs" },
+            configs: { $ref: "#/components/schemas/BoundedConfigPage" }
+          }
+        },
+        ProfileResolutionRead: {
+          type: "object",
+          required: ["profile", "scanned", "total", "batch_limit", "source_bounded", "complete", "truncated"],
+          properties: {
+            profile: { oneOf: [{ $ref: "#/components/schemas/Profile" }, { type: "null" }] },
+            scanned: { type: "number", nullable: true },
+            total: { type: "number", nullable: true },
+            batch_limit: { type: "number", nullable: true },
+            source_bounded: { type: "boolean" },
+            complete: { type: "boolean", const: true },
+            truncated: { type: "boolean", const: false }
+          }
         }
       }
     },
@@ -3127,18 +3314,16 @@ function buildV1OpenApiDocument(version = getPackageVersion()) {
       "/v1/profiles": {
         get: {
           operationId: "listProfiles",
-          summary: "List profiles",
+          summary: "List profiles with producer-side bounds",
+          parameters: [
+            { name: "limit", in: "query", schema: { type: "integer", minimum: 1, maximum: 100 } },
+            { name: "cursor", in: "query", schema: { type: "integer", minimum: 0 } }
+          ],
           responses: {
             "200": {
               content: {
                 "application/json": {
-                  schema: {
-                    type: "object",
-                    properties: {
-                      profiles: { type: "array", items: { $ref: "#/components/schemas/Profile" } },
-                      count: { type: "number" }
-                    }
-                  }
+                  schema: { $ref: "#/components/schemas/BoundedProfilePage" }
                 }
               }
             }
@@ -3154,12 +3339,37 @@ function buildV1OpenApiDocument(version = getPackageVersion()) {
           responses: { "201": { content: { "application/json": { schema: { type: "object", properties: { profile: { $ref: "#/components/schemas/Profile" } } } } } } }
         }
       },
+      "/v1/profiles/resolve": {
+        get: {
+          operationId: "resolveProfile",
+          summary: "Resolve a machine profile by scanning producer-bounded batches",
+          parameters: [
+            { name: "hostname", in: "query", schema: { type: "string" } },
+            { name: "os", in: "query", schema: { type: "string" } },
+            { name: "arch", in: "query", schema: { type: "string" } },
+            { name: "limit", in: "query", schema: { type: "integer", minimum: 1, maximum: 100 } }
+          ],
+          responses: {
+            "200": {
+              content: {
+                "application/json": {
+                  schema: { $ref: "#/components/schemas/ProfileResolutionRead" }
+                }
+              }
+            }
+          }
+        }
+      },
       "/v1/profiles/{id}": {
         get: {
           operationId: "getProfile",
           summary: "Get a profile (with its configs) by id or slug",
-          parameters: [{ name: "id", in: "path", required: true, schema: { type: "string" } }],
-          responses: { "200": { content: { "application/json": { schema: { type: "object", properties: { profile: { $ref: "#/components/schemas/Profile" } } } } } } }
+          parameters: [
+            { name: "id", in: "path", required: true, schema: { type: "string" } },
+            { name: "limit", in: "query", schema: { type: "integer", minimum: 1, maximum: 100 } },
+            { name: "cursor", in: "query", schema: { type: "integer", minimum: 0 } }
+          ],
+          responses: { "200": { content: { "application/json": { schema: { $ref: "#/components/schemas/ProfileShowResponse" } } } } }
         },
         delete: {
           operationId: "deleteProfile",

package/dist/server/openapi.d.ts

@@ -198,6 +198,177 @@ export declare function buildV1OpenApiDocument(version?: string): {
                     };
                 };
             };
+            ProfileWithConfigs: {
+                type: string;
+                properties: {
+                    configs: {
+                        type: string;
+                        items: {
+                            $ref: string;
+                        };
+                    };
+                    id: {
+                        readonly type: "string";
+                    };
+                    name: {
+                        readonly type: "string";
+                    };
+                    slug: {
+                        readonly type: "string";
+                    };
+                    description: {
+                        readonly type: "string";
+                        readonly nullable: true;
+                    };
+                    selectors: {
+                        readonly type: "object";
+                    };
+                    variables: {
+                        readonly type: "object";
+                    };
+                    created_at: {
+                        readonly type: "string";
+                    };
+                    updated_at: {
+                        readonly type: "string";
+                    };
+                };
+            };
+            BoundedProfilePage: {
+                type: string;
+                required: string[];
+                properties: {
+                    profiles: {
+                        type: string;
+                        items: {
+                            $ref: string;
+                        };
+                    };
+                    items: {
+                        type: string;
+                        items: {
+                            $ref: string;
+                        };
+                    };
+                    count: {
+                        type: string;
+                    };
+                    total: {
+                        type: string;
+                    };
+                    limit: {
+                        type: string;
+                    };
+                    cursor: {
+                        type: string;
+                    };
+                    next_cursor: {
+                        type: string;
+                        nullable: boolean;
+                    };
+                    has_more: {
+                        type: string;
+                    };
+                    complete: {
+                        type: string;
+                    };
+                    truncated: {
+                        type: string;
+                        const: boolean;
+                    };
+                    source_bounded: {
+                        type: string;
+                    };
+                };
+            };
+            BoundedConfigPage: {
+                type: string;
+                required: string[];
+                properties: {
+                    items: {
+                        type: string;
+                        items: {
+                            $ref: string;
+                        };
+                    };
+                    total: {
+                        type: string;
+                    };
+                    limit: {
+                        type: string;
+                    };
+                    cursor: {
+                        type: string;
+                    };
+                    next_cursor: {
+                        type: string;
+                        nullable: boolean;
+                    };
+                    has_more: {
+                        type: string;
+                    };
+                    complete: {
+                        type: string;
+                    };
+                    truncated: {
+                        type: string;
+                        const: boolean;
+                    };
+                    source_bounded: {
+                        type: string;
+                    };
+                };
+            };
+            ProfileShowResponse: {
+                type: string;
+                required: string[];
+                properties: {
+                    profile: {
+                        $ref: string;
+                    };
+                    configs: {
+                        $ref: string;
+                    };
+                };
+            };
+            ProfileResolutionRead: {
+                type: string;
+                required: string[];
+                properties: {
+                    profile: {
+                        oneOf: ({
+                            $ref: string;
+                            type?: undefined;
+                        } | {
+                            type: string;
+                            $ref?: undefined;
+                        })[];
+                    };
+                    scanned: {
+                        type: string;
+                        nullable: boolean;
+                    };
+                    total: {
+                        type: string;
+                        nullable: boolean;
+                    };
+                    batch_limit: {
+                        type: string;
+                        nullable: boolean;
+                    };
+                    source_bounded: {
+                        type: string;
+                    };
+                    complete: {
+                        type: string;
+                        const: boolean;
+                    };
+                    truncated: {
+                        type: string;
+                        const: boolean;
+                    };
+                };
+            };
         };
     };
     security: {
@@ -436,23 +607,29 @@ export declare function buildV1OpenApiDocument(version?: string): {
             get: {
                 operationId: string;
                 summary: string;
+                parameters: ({
+                    name: string;
+                    in: string;
+                    schema: {
+                        type: string;
+                        minimum: number;
+                        maximum: number;
+                    };
+                } | {
+                    name: string;
+                    in: string;
+                    schema: {
+                        type: string;
+                        minimum: number;
+                        maximum?: undefined;
+                    };
+                })[];
                 responses: {
                     "200": {
                         content: {
                             "application/json": {
                                 schema: {
-                                    type: string;
-                                    properties: {
-                                        profiles: {
-                                            type: string;
-                                            items: {
-                                                $ref: string;
-                                            };
-                                        };
-                                        count: {
-                                            type: string;
-                                        };
-                                    };
+                                    $ref: string;
                                 };
                             };
                         };
@@ -490,29 +667,78 @@ export declare function buildV1OpenApiDocument(version?: string): {
                 };
             };
         };
+        "/v1/profiles/resolve": {
+            get: {
+                operationId: string;
+                summary: string;
+                parameters: ({
+                    name: string;
+                    in: string;
+                    schema: {
+                        type: string;
+                        minimum?: undefined;
+                        maximum?: undefined;
+                    };
+                } | {
+                    name: string;
+                    in: string;
+                    schema: {
+                        type: string;
+                        minimum: number;
+                        maximum: number;
+                    };
+                })[];
+                responses: {
+                    "200": {
+                        content: {
+                            "application/json": {
+                                schema: {
+                                    $ref: string;
+                                };
+                            };
+                        };
+                    };
+                };
+            };
+        };
         "/v1/profiles/{id}": {
             get: {
                 operationId: string;
                 summary: string;
-                parameters: {
+                parameters: ({
                     name: string;
                     in: string;
                     required: boolean;
                     schema: {
                         type: string;
+                        minimum?: undefined;
+                        maximum?: undefined;
                     };
-                }[];
+                } | {
+                    name: string;
+                    in: string;
+                    schema: {
+                        type: string;
+                        minimum: number;
+                        maximum: number;
+                    };
+                    required?: undefined;
+                } | {
+                    name: string;
+                    in: string;
+                    schema: {
+                        type: string;
+                        minimum: number;
+                        maximum?: undefined;
+                    };
+                    required?: undefined;
+                })[];
                 responses: {
                     "200": {
                         content: {
                             "application/json": {
                                 schema: {
-                                    type: string;
-                                    properties: {
-                                        profile: {
-                                            $ref: string;
-                                        };
-                                    };
+                                    $ref: string;
                                 };
                             };
                         };

package/dist/server/openapi.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"openapi.d.ts","sourceRoot":"","sources":["../../src/server/openapi.ts"],"names":[],"mappings":"AA4CA,wBAAgB,sBAAsB,CAAC,OAAO,SAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA0NnE"}
+{"version":3,"file":"openapi.d.ts","sourceRoot":"","sources":["../../src/server/openapi.ts"],"names":[],"mappings":"AA4CA,wBAAgB,sBAAsB,CAAC,OAAO,SAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA6SnE"}