@refkit/core 0.1.0

package/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or Derivative
+          Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work, excluding
+          those notices that do not pertain to any part of the Derivative
+          Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2026 refkit authors
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -0,0 +1,12 @@
+# @refkit/core
+
+Neutral reference-retrieval core. **Zero network, zero providers, only depends on `zod`.**
+
+Invariants (enforced by `src/__tests__/no-network.test.ts`):
+- No `fetch` call and no hard-coded endpoint in this package. Hosts inject `ProviderContext.fetch`.
+- No import of any host/orchestration framework. This package is substrate-agnostic.
+- Only `zod` as a non-relative dependency.
+
+This is a heuristic tool, **not legal advice**. `evaluateUse` returns a conservative
+verdict based on source-declared license/ToS facts; it does not determine legal rights.
+Never re-host originals: keep `canonicalUrl` + thumbnails only.

package/dist/index.d.ts

@@ -0,0 +1,199 @@
+import { z } from 'zod';
+
+type Modality = 'image' | 'video' | 'audio' | 'text';
+
+type LicenseId = 'CC0-1.0' | 'CC-BY' | 'CC-BY-SA' | 'PD' | 'unsplash' | 'pexels' | 'pixabay' | 'proprietary' | 'unknown';
+/** Three-state: known-true / known-false / not-determinable. Drives strict-deny. */
+type Tri = true | false | 'unknown';
+interface LicenseFacts {
+    commercialUse: Tri;
+    derivatives: Tri;
+    redistribution: Tri;
+    attributionRequired: boolean;
+    shareAlike: boolean;
+}
+declare const LICENSE_FACTS: Record<LicenseId, LicenseFacts>;
+/** Resolve facts for a license id; unrecognized → `unknown` (strict-deny fallback). */
+declare function factsFor(license: LicenseId): LicenseFacts;
+
+type RehostPolicy = 'hotlink-required' | 'cache-allowed' | 'thumbnail-only' | 'no-store';
+interface RightsRecord {
+    license: LicenseId;
+    /** Precise CC version ("4.0", "3.0", …) for family ids (CC-BY/CC-BY-SA).
+     *  Attribution/audit only — never read by evaluateUse. Omitted for non-CC. */
+    licenseVersion?: string;
+    /** Per-item attribution datum; attribution text is generated, not stored. */
+    author?: string;
+    rehostPolicy: RehostPolicy;
+    /** Source-declared jurisdiction of the PD/copyright status (e.g. 'US'). P0: metadata only. */
+    jurisdiction?: string;
+    editorialOnly?: boolean;
+    /** Auditable anchor back to the source's stated terms. */
+    raw: {
+        sourceTerms: string;
+        sourceUrl: string;
+    };
+}
+declare const rightsRecordSchema: z.ZodType<RightsRecord>;
+
+interface Attribution {
+    required: boolean;
+    text?: string;
+    html?: string;
+}
+interface AttributionInput {
+    license: LicenseId;
+    /** Precise CC version for family ids; appended to the license name in the credit line. */
+    licenseVersion?: string;
+    canonicalUrl: string;
+    author?: string;
+    title?: string;
+}
+declare function buildAttribution(input: AttributionInput): Attribution;
+
+interface ReferenceMedia {
+    url: string;
+    width?: number;
+    height?: number;
+}
+interface MediaPreview {
+    url: string;
+    mediaType: string;
+    width?: number;
+    height?: number;
+}
+interface VisualMeta {
+    width: number;
+    height: number;
+    dominantColors?: string[];
+}
+interface TextMeta {
+    excerpt: string;
+    excerptKind: 'passage' | 'structure' | 'quote';
+    locator?: string;
+}
+interface Reference {
+    id: string;
+    modality: Modality;
+    title?: string;
+    source: {
+        providerId: string;
+        sourceUrl: string;
+    };
+    canonicalUrl: string;
+    rights: RightsRecord;
+    verifiedAt: string;
+    thumbnail?: ReferenceMedia;
+    preview?: MediaPreview;
+    perceptualHash?: string;
+    visual?: VisualMeta;
+    text?: TextMeta;
+    relevance: number;
+    raw?: unknown;
+}
+declare const referenceSchema: z.ZodType<Reference>;
+/** Validate a provider-emitted reference at the core boundary. Throws on malformed input. */
+declare function parseReference(input: unknown): Reference;
+
+declare function fnv1a(str: string): string;
+
+declare function canonicalizeUrl(url: string): string;
+/** Content-addressed id: stable within a result set, not promised across calls. */
+declare function referenceId(providerId: string, sourceUrl: string): string;
+
+/** Bitwise hamming distance between two equal-length lowercase hex strings. */
+declare function hammingDistance(a: string, b: string): number;
+interface DedupeOptions {
+    /** Max hamming distance between perceptual hashes to treat as duplicates. Default 0 (off). */
+    hashThreshold?: number;
+}
+declare function dedupeReferences(refs: Reference[], opts?: DedupeOptions): Reference[];
+
+interface MergeOptions extends DedupeOptions {
+    /** RRF dampening constant. Standard default 60. */
+    k?: number;
+}
+declare function mergeReferences(perSource: Reference[][], opts?: MergeOptions): Reference[];
+
+type Intent = 'internal-moodboard' | 'commercial-product' | 'ai-generation-input' | 'redistribution';
+type Decision = 'allowed' | 'allowed-with-attribution' | 'denied' | 'needs-review';
+interface Verdict {
+    decision: Decision;
+    reasons: string[];
+    confidence: 'high' | 'low';
+    disclaimer: string;
+}
+declare const NOT_LEGAL_ADVICE = "Heuristic based on source-declared license/ToS facts; not legal advice.";
+declare function evaluateUse(r: RightsRecord, intent: Intent, ctx?: {
+    userJurisdiction?: string;
+}): Verdict;
+
+type QueryFeature = 'keyword' | 'color' | 'orientation' | 'license-filter' | 'author' | 'language';
+interface SearchFilters {
+    color?: string;
+    orientation?: 'landscape' | 'portrait' | 'square';
+    language?: string;
+}
+interface NormalizedQuery {
+    text: string;
+    modalities: Modality[];
+    filters?: SearchFilters;
+    limit?: number;
+}
+interface KeyValueCache {
+    get(key: string): Promise<string | undefined>;
+    set(key: string, value: string, ttlMs?: number): Promise<void>;
+}
+interface ProviderContext {
+    fetch: typeof fetch;
+    cache?: KeyValueCache;
+    signal?: AbortSignal;
+}
+interface ReferenceProvider {
+    id: string;
+    modalities: Modality[];
+    queryFeatures: QueryFeature[];
+    search(query: NormalizedQuery, ctx: ProviderContext): Promise<Reference[]>;
+}
+/** Identity helper for type inference when authoring a provider factory. */
+declare function defineProvider(p: ReferenceProvider): ReferenceProvider;
+
+declare function normalizeQuery(input: {
+    query: string;
+    modalities: Modality[];
+    filters?: SearchFilters;
+    limit?: number;
+}, provider: ReferenceProvider): NormalizedQuery;
+
+interface RefkitOptions {
+    providers: ReferenceProvider[];
+    fetch?: typeof fetch;
+    cache?: KeyValueCache;
+    signal?: AbortSignal;
+    merge?: MergeOptions;
+}
+interface ProviderError {
+    providerId: string;
+    error: unknown;
+}
+interface SearchInput {
+    query: string;
+    modalities: Modality[];
+    filters?: SearchFilters;
+    limit?: number;
+    signal?: AbortSignal;
+    gateFor?: Intent;
+    onProviderError?: (e: ProviderError) => void;
+    rerank?: (refs: Reference[]) => Reference[] | Promise<Reference[]>;
+}
+interface RefkitClient {
+    search(input: SearchInput): Promise<Reference[]>;
+    evaluateUse(ref: Reference, intent: Intent, ctx?: {
+        userJurisdiction?: string;
+    }): Verdict;
+    buildAttribution(ref: Reference): Attribution;
+    readonly providers: readonly ReferenceProvider[];
+}
+declare function createRefkit(options: RefkitOptions): RefkitClient;
+
+export { type Attribution, type AttributionInput, type Decision, type DedupeOptions, type Intent, type KeyValueCache, LICENSE_FACTS, type LicenseFacts, type LicenseId, type MediaPreview, type MergeOptions, type Modality, NOT_LEGAL_ADVICE, type NormalizedQuery, type ProviderContext, type ProviderError, type QueryFeature, type Reference, type ReferenceMedia, type ReferenceProvider, type RefkitClient, type RefkitOptions, type RehostPolicy, type RightsRecord, type SearchFilters, type SearchInput, type TextMeta, type Tri, type Verdict, type VisualMeta, buildAttribution, canonicalizeUrl, createRefkit, dedupeReferences, defineProvider, evaluateUse, factsFor, fnv1a, hammingDistance, mergeReferences, normalizeQuery, parseReference, referenceId, referenceSchema, rightsRecordSchema };

package/dist/index.js

@@ -0,0 +1,351 @@
+// src/license.ts
+var LICENSE_FACTS = {
+  "CC0-1.0": { commercialUse: true, derivatives: true, redistribution: true, attributionRequired: false, shareAlike: false },
+  "PD": { commercialUse: true, derivatives: true, redistribution: true, attributionRequired: false, shareAlike: false },
+  "CC-BY": { commercialUse: true, derivatives: true, redistribution: true, attributionRequired: true, shareAlike: false },
+  "CC-BY-SA": { commercialUse: true, derivatives: true, redistribution: true, attributionRequired: true, shareAlike: true },
+  // Stock-platform licenses: free to use incl. commercial, no attribution legally
+  // required, but NOT redistributable as-is (can't resell/redistribute the asset itself).
+  "unsplash": { commercialUse: true, derivatives: true, redistribution: false, attributionRequired: false, shareAlike: false },
+  "pexels": { commercialUse: true, derivatives: true, redistribution: false, attributionRequired: false, shareAlike: false },
+  "pixabay": { commercialUse: true, derivatives: true, redistribution: false, attributionRequired: false, shareAlike: false },
+  "proprietary": { commercialUse: false, derivatives: false, redistribution: false, attributionRequired: false, shareAlike: false },
+  "unknown": { commercialUse: "unknown", derivatives: "unknown", redistribution: "unknown", attributionRequired: false, shareAlike: false }
+};
+function factsFor(license) {
+  return LICENSE_FACTS[license] ?? LICENSE_FACTS.unknown;
+}
+
+// src/rights.ts
+import { z } from "zod";
+var licenseIdSchema = z.enum([
+  "CC0-1.0",
+  "CC-BY",
+  "CC-BY-SA",
+  "PD",
+  "unsplash",
+  "pexels",
+  "pixabay",
+  "proprietary",
+  "unknown"
+]);
+var rightsRecordSchema = z.object({
+  license: licenseIdSchema,
+  licenseVersion: z.string().optional(),
+  author: z.string().optional(),
+  rehostPolicy: z.enum(["hotlink-required", "cache-allowed", "thumbnail-only", "no-store"]),
+  jurisdiction: z.string().optional(),
+  editorialOnly: z.boolean().optional(),
+  raw: z.object({ sourceTerms: z.string(), sourceUrl: z.string() })
+});
+
+// src/attribution.ts
+function escapeHtml(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+function buildAttribution(input) {
+  const facts = factsFor(input.license);
+  if (!facts.attributionRequired) return { required: false };
+  const author = input.author ?? "Unknown author";
+  const licenseLabel = input.licenseVersion ? `${input.license} ${input.licenseVersion}` : input.license;
+  const titlePart = input.title ? `"${input.title}" ` : "";
+  const text = `${titlePart}by ${author} is licensed under ${licenseLabel}. Source: ${input.canonicalUrl}`;
+  const url = escapeHtml(input.canonicalUrl);
+  const titleHtml = input.title ? `&quot;${escapeHtml(input.title)}&quot; ` : "";
+  const html = `${titleHtml}by ${escapeHtml(author)} is licensed under ${escapeHtml(licenseLabel)}. <a href="${url}">Source</a>`;
+  return { required: true, text, html };
+}
+
+// src/reference.ts
+import { z as z2 } from "zod";
+var modalitySchema = z2.enum(["image", "video", "audio", "text"]);
+var referenceSchema = z2.object({
+  id: z2.string().min(1),
+  modality: modalitySchema,
+  title: z2.string().optional(),
+  source: z2.object({ providerId: z2.string().min(1), sourceUrl: z2.string().min(1) }),
+  canonicalUrl: z2.string().min(1),
+  rights: rightsRecordSchema,
+  verifiedAt: z2.string().datetime(),
+  thumbnail: z2.object({ url: z2.string(), width: z2.number().optional(), height: z2.number().optional() }).optional(),
+  preview: z2.object({ url: z2.string(), mediaType: z2.string(), width: z2.number().optional(), height: z2.number().optional() }).optional(),
+  perceptualHash: z2.string().optional(),
+  visual: z2.object({ width: z2.number(), height: z2.number(), dominantColors: z2.array(z2.string()).optional() }).optional(),
+  text: z2.object({
+    excerpt: z2.string(),
+    excerptKind: z2.enum(["passage", "structure", "quote"]),
+    locator: z2.string().optional()
+  }).optional(),
+  relevance: z2.number().min(0).max(1),
+  raw: z2.unknown().optional()
+});
+function parseReference(input) {
+  return referenceSchema.parse(input);
+}
+
+// src/hash.ts
+function fnv1a(str) {
+  let h = 2166136261;
+  for (let i = 0; i < str.length; i++) {
+    h ^= str.charCodeAt(i);
+    h = Math.imul(h, 16777619);
+  }
+  return (h >>> 0).toString(36);
+}
+
+// src/dedup-key.ts
+function canonicalizeUrl(url) {
+  try {
+    const u = new URL(url);
+    u.hash = "";
+    u.protocol = u.protocol.toLowerCase();
+    u.hostname = u.hostname.toLowerCase();
+    let out = u.toString();
+    if (out.endsWith("/") && !out.endsWith("://")) out = out.slice(0, -1);
+    return out;
+  } catch {
+    return url;
+  }
+}
+function referenceId(providerId, sourceUrl) {
+  return `${providerId}:${fnv1a(canonicalizeUrl(sourceUrl))}`;
+}
+
+// src/dedup.ts
+var HEX_BITS = {
+  "0": 0,
+  "1": 1,
+  "2": 1,
+  "3": 2,
+  "4": 1,
+  "5": 2,
+  "6": 2,
+  "7": 3,
+  "8": 1,
+  "9": 2,
+  a: 2,
+  b: 3,
+  c: 2,
+  d: 3,
+  e: 3,
+  f: 4
+};
+function hammingDistance(a, b) {
+  if (a.length !== b.length) return Infinity;
+  let d = 0;
+  for (let i = 0; i < a.length; i++) {
+    if (a[i] === b[i]) continue;
+    const xor = (parseInt(a[i], 16) ^ parseInt(b[i], 16)).toString(16);
+    d += HEX_BITS[xor] ?? 4;
+  }
+  return d;
+}
+function dedupeReferences(refs, opts = {}) {
+  const threshold = opts.hashThreshold ?? 0;
+  const kept = [];
+  const byUrl = /* @__PURE__ */ new Map();
+  for (const ref of refs) {
+    const url = canonicalizeUrl(ref.canonicalUrl);
+    const urlHit = byUrl.get(url);
+    if (urlHit !== void 0) {
+      if (ref.relevance > kept[urlHit].relevance) kept[urlHit] = ref;
+      continue;
+    }
+    let merged = false;
+    if (threshold > 0 && ref.perceptualHash) {
+      for (let i = 0; i < kept.length; i++) {
+        const k = kept[i];
+        if (k.perceptualHash && hammingDistance(ref.perceptualHash, k.perceptualHash) <= threshold) {
+          if (ref.relevance > k.relevance) {
+            byUrl.delete(canonicalizeUrl(k.canonicalUrl));
+            byUrl.set(canonicalizeUrl(ref.canonicalUrl), i);
+            kept[i] = ref;
+          }
+          merged = true;
+          break;
+        }
+      }
+    }
+    if (merged) continue;
+    byUrl.set(url, kept.length);
+    kept.push(ref);
+  }
+  return kept;
+}
+
+// src/merge.ts
+function mergeReferences(perSource, opts = {}) {
+  const k = opts.k ?? 60;
+  const score = /* @__PURE__ */ new Map();
+  const rep = /* @__PURE__ */ new Map();
+  for (const list of perSource) {
+    list.forEach((ref, rank) => {
+      const key = canonicalizeUrl(ref.canonicalUrl);
+      score.set(key, (score.get(key) ?? 0) + 1 / (k + rank));
+      const cur = rep.get(key);
+      if (!cur || ref.relevance > cur.relevance) rep.set(key, ref);
+    });
+  }
+  const maxScore = Math.max(...score.values());
+  const fused = [...score.entries()].map(([key, s]) => ({ ...rep.get(key), relevance: s / maxScore })).sort((a, b) => b.relevance - a.relevance);
+  return dedupeReferences(fused, opts);
+}
+
+// src/evaluate-use.ts
+var NOT_LEGAL_ADVICE = "Heuristic based on source-declared license/ToS facts; not legal advice.";
+function requiredPermissions(intent) {
+  switch (intent) {
+    case "commercial-product":
+      return ["commercialUse"];
+    case "ai-generation-input":
+      return ["commercialUse", "derivatives"];
+    case "redistribution":
+      return ["redistribution"];
+    case "internal-moodboard":
+      return [];
+  }
+}
+function evaluateUse(r, intent, ctx) {
+  const facts = factsFor(r.license);
+  const reasons = [];
+  const confidence = r.license === "unknown" ? "low" : "high";
+  const base = { reasons, confidence, disclaimer: NOT_LEGAL_ADVICE };
+  const commercialIntent = intent === "commercial-product" || intent === "ai-generation-input";
+  if (r.license === "unknown") {
+    reasons.push("license could not be determined (strict-deny)");
+    return { decision: "needs-review", ...base };
+  }
+  if (r.editorialOnly && commercialIntent) {
+    reasons.push("source marked editorial-only");
+    return { decision: "denied", ...base };
+  }
+  if (ctx?.userJurisdiction && r.jurisdiction && ctx.userJurisdiction !== r.jurisdiction) {
+    reasons.push(`source jurisdiction ${r.jurisdiction} != user jurisdiction ${ctx.userJurisdiction}`);
+    return { decision: "needs-review", ...base };
+  }
+  for (const perm of requiredPermissions(intent)) {
+    const value = facts[perm];
+    if (value === false) {
+      reasons.push(`${perm} not granted by ${r.license}`);
+      return { decision: "denied", ...base };
+    }
+    if (value === "unknown") {
+      reasons.push(`${perm} undetermined for ${r.license}`);
+      return { decision: "needs-review", ...base };
+    }
+  }
+  reasons.push(`permitted for ${intent} under ${r.license}`);
+  if (facts.attributionRequired && intent === "internal-moodboard") {
+    reasons.push("attribution required by license but not enforced for internal-moodboard use");
+  }
+  const decision = facts.attributionRequired && intent !== "internal-moodboard" ? "allowed-with-attribution" : "allowed";
+  return { decision, ...base };
+}
+
+// src/provider.ts
+function defineProvider(p) {
+  return p;
+}
+
+// src/query.ts
+function normalizeQuery(input, provider) {
+  const feats = new Set(provider.queryFeatures);
+  const filters = {};
+  if (input.filters?.color && feats.has("color")) filters.color = input.filters.color;
+  if (input.filters?.orientation && feats.has("orientation")) filters.orientation = input.filters.orientation;
+  if (input.filters?.language && feats.has("language")) filters.language = input.filters.language;
+  const hasFilters = Object.keys(filters).length > 0;
+  return {
+    text: input.query,
+    modalities: input.modalities.filter((m) => provider.modalities.includes(m)),
+    ...hasFilters ? { filters } : {},
+    ...input.limit !== void 0 ? { limit: input.limit } : {}
+  };
+}
+
+// src/client.ts
+var DEFAULT_LIMIT = 30;
+function createRefkit(options) {
+  if (!options.providers || options.providers.length === 0) {
+    throw new Error("createRefkit: at least one provider is required");
+  }
+  async function search(input) {
+    const doFetch = options.fetch ?? globalThis.fetch;
+    if (typeof doFetch !== "function") {
+      throw new Error("createRefkit: no fetch available \u2014 pass options.fetch");
+    }
+    const ctx = {
+      fetch: doFetch,
+      cache: options.cache,
+      signal: input.signal ?? options.signal
+    };
+    const chosen = options.providers.filter((p) => p.modalities.some((m) => input.modalities.includes(m)));
+    if (chosen.length === 0) {
+      throw new Error(`refkit.search: no registered provider supports modalities [${input.modalities.join(", ")}]`);
+    }
+    const settled = await Promise.allSettled(chosen.map((p) => p.search(normalizeQuery(input, p), ctx)));
+    const perSource = [];
+    let anyOk = false;
+    settled.forEach((res, i) => {
+      const provider = chosen[i];
+      if (res.status === "fulfilled") {
+        anyOk = true;
+        const valid = [];
+        for (const raw of res.value) {
+          try {
+            valid.push(parseReference(raw));
+          } catch (error) {
+            input.onProviderError?.({ providerId: provider.id, error });
+          }
+        }
+        perSource.push(valid);
+      } else {
+        input.onProviderError?.({ providerId: provider.id, error: res.reason });
+      }
+    });
+    if (!anyOk) {
+      const reasons = settled.filter((s) => s.status === "rejected").map((s) => s.reason);
+      throw new AggregateError(reasons, "refkit.search: all providers failed");
+    }
+    let refs = mergeReferences(perSource, options.merge);
+    if (input.rerank) refs = await input.rerank(refs);
+    if (input.gateFor) {
+      const intent = input.gateFor;
+      refs = refs.filter((r) => evaluateUse(r.rights, intent).decision.startsWith("allowed"));
+    }
+    return refs.slice(0, input.limit ?? DEFAULT_LIMIT);
+  }
+  return {
+    search,
+    evaluateUse: (ref, intent, ctx) => evaluateUse(ref.rights, intent, ctx),
+    buildAttribution: (ref) => buildAttribution({
+      license: ref.rights.license,
+      author: ref.rights.author,
+      title: ref.title,
+      canonicalUrl: ref.canonicalUrl
+    }),
+    get providers() {
+      return options.providers;
+    }
+  };
+}
+export {
+  LICENSE_FACTS,
+  NOT_LEGAL_ADVICE,
+  buildAttribution,
+  canonicalizeUrl,
+  createRefkit,
+  dedupeReferences,
+  defineProvider,
+  evaluateUse,
+  factsFor,
+  fnv1a,
+  hammingDistance,
+  mergeReferences,
+  normalizeQuery,
+  parseReference,
+  referenceId,
+  referenceSchema,
+  rightsRecordSchema
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/license.ts","../src/rights.ts","../src/attribution.ts","../src/reference.ts","../src/hash.ts","../src/dedup-key.ts","../src/dedup.ts","../src/merge.ts","../src/evaluate-use.ts","../src/provider.ts","../src/query.ts","../src/client.ts"],"sourcesContent":["export type LicenseId =\n  | 'CC0-1.0'\n  | 'CC-BY'\n  | 'CC-BY-SA'\n  | 'PD'\n  | 'unsplash'\n  | 'pexels'\n  | 'pixabay'\n  | 'proprietary'\n  | 'unknown'\n\n/** Three-state: known-true / known-false / not-determinable. Drives strict-deny. */\nexport type Tri = true | false | 'unknown'\n\nexport interface LicenseFacts {\n  commercialUse: Tri\n  derivatives: Tri\n  redistribution: Tri\n  attributionRequired: boolean\n  shareAlike: boolean\n}\n\n// Canonical, auditable license facts. The single source of truth for permissions —\n// RightsRecord stores the license id; permissions are derived via factsFor(), never\n// duplicated. Conservative by design: anything not clearly granted is false/unknown.\nexport const LICENSE_FACTS: Record<LicenseId, LicenseFacts> = {\n  'CC0-1.0': { commercialUse: true, derivatives: true, redistribution: true, attributionRequired: false, shareAlike: false },\n  'PD': { commercialUse: true, derivatives: true, redistribution: true, attributionRequired: false, shareAlike: false },\n  'CC-BY': { commercialUse: true, derivatives: true, redistribution: true, attributionRequired: true, shareAlike: false },\n  'CC-BY-SA': { commercialUse: true, derivatives: true, redistribution: true, attributionRequired: true, shareAlike: true },\n  // Stock-platform licenses: free to use incl. commercial, no attribution legally\n  // required, but NOT redistributable as-is (can't resell/redistribute the asset itself).\n  'unsplash': { commercialUse: true, derivatives: true, redistribution: false, attributionRequired: false, shareAlike: false },\n  'pexels': { commercialUse: true, derivatives: true, redistribution: false, attributionRequired: false, shareAlike: false },\n  'pixabay': { commercialUse: true, derivatives: true, redistribution: false, attributionRequired: false, shareAlike: false },\n  'proprietary': { commercialUse: false, derivatives: false, redistribution: false, attributionRequired: false, shareAlike: false },\n  'unknown': { commercialUse: 'unknown', derivatives: 'unknown', redistribution: 'unknown', attributionRequired: false, shareAlike: false },\n}\n\n/** Resolve facts for a license id; unrecognized → `unknown` (strict-deny fallback). */\nexport function factsFor(license: LicenseId): LicenseFacts {\n  return LICENSE_FACTS[license] ?? LICENSE_FACTS.unknown\n}\n","import { z } from 'zod'\nimport type { LicenseId } from './license'\n\nexport type RehostPolicy = 'hotlink-required' | 'cache-allowed' | 'thumbnail-only' | 'no-store'\n\n// What a satellite emits per result. Permissions are NOT stored here — they are\n// derived from `license` via factsFor() (one source of truth). Only per-item data\n// (author, rehost quirk, jurisdiction) and an auditable raw anchor live here.\nexport interface RightsRecord {\n  license: LicenseId\n  /** Precise CC version (\"4.0\", \"3.0\", …) for family ids (CC-BY/CC-BY-SA).\n   *  Attribution/audit only — never read by evaluateUse. Omitted for non-CC. */\n  licenseVersion?: string\n  /** Per-item attribution datum; attribution text is generated, not stored. */\n  author?: string\n  rehostPolicy: RehostPolicy\n  /** Source-declared jurisdiction of the PD/copyright status (e.g. 'US'). P0: metadata only. */\n  jurisdiction?: string\n  editorialOnly?: boolean\n  /** Auditable anchor back to the source's stated terms. */\n  raw: { sourceTerms: string; sourceUrl: string }\n}\n\nconst licenseIdSchema: z.ZodType<LicenseId> = z.enum([\n  'CC0-1.0', 'CC-BY', 'CC-BY-SA', 'PD',\n  'unsplash', 'pexels', 'pixabay', 'proprietary', 'unknown',\n])\n\nexport const rightsRecordSchema: z.ZodType<RightsRecord> = z.object({\n  license: licenseIdSchema,\n  licenseVersion: z.string().optional(),\n  author: z.string().optional(),\n  rehostPolicy: z.enum(['hotlink-required', 'cache-allowed', 'thumbnail-only', 'no-store']),\n  jurisdiction: z.string().optional(),\n  editorialOnly: z.boolean().optional(),\n  raw: z.object({ sourceTerms: z.string(), sourceUrl: z.string() }),\n})\n","import { factsFor, type LicenseId } from './license'\n\nexport interface Attribution {\n  required: boolean\n  text?: string\n  html?: string\n}\n\nexport interface AttributionInput {\n  license: LicenseId\n  /** Precise CC version for family ids; appended to the license name in the credit line. */\n  licenseVersion?: string\n  canonicalUrl: string\n  author?: string\n  title?: string\n}\n\nfunction escapeHtml(s: string): string {\n  return s.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/\"/g, '&quot;')\n}\n\n// Mechanically derive attribution from license + author + title + canonicalUrl, so\n// satellites pass fields (not hand-written strings) and credit lines stay consistent.\nexport function buildAttribution(input: AttributionInput): Attribution {\n  const facts = factsFor(input.license)\n  if (!facts.attributionRequired) return { required: false }\n\n  const author = input.author ?? 'Unknown author'\n  const licenseLabel = input.licenseVersion ? `${input.license} ${input.licenseVersion}` : input.license\n  const titlePart = input.title ? `\"${input.title}\" ` : ''\n  const text = `${titlePart}by ${author} is licensed under ${licenseLabel}. Source: ${input.canonicalUrl}`\n\n  const url = escapeHtml(input.canonicalUrl)\n  const titleHtml = input.title ? `&quot;${escapeHtml(input.title)}&quot; ` : ''\n  const html = `${titleHtml}by ${escapeHtml(author)} is licensed under ${escapeHtml(licenseLabel)}. <a href=\"${url}\">Source</a>`\n\n  return { required: true, text, html }\n}\n","import { z } from 'zod'\nimport type { Modality } from './modality'\nimport { rightsRecordSchema, type RightsRecord } from './rights'\n\nexport interface ReferenceMedia { url: string; width?: number; height?: number }\nexport interface MediaPreview { url: string; mediaType: string; width?: number; height?: number }\nexport interface VisualMeta { width: number; height: number; dominantColors?: string[] }\nexport interface TextMeta {\n  excerpt: string\n  excerptKind: 'passage' | 'structure' | 'quote'\n  locator?: string\n}\n\nexport interface Reference {\n  // content-addressed, stable within a single result set only (core is zero-storage).\n  id: string\n  modality: Modality\n  title?: string\n  // — provenance (required; a result missing any of these never enters the set) —\n  source: { providerId: string; sourceUrl: string }\n  canonicalUrl: string\n  rights: RightsRecord\n  verifiedAt: string // ISO; = the moment the satellite parsed rights (not a ToS-drift signal)\n  // — carriers —\n  thumbnail?: ReferenceMedia\n  preview?: MediaPreview\n  // computed by the satellite (pHash/blockhash); core only compares it, never decodes bytes.\n  perceptualHash?: string\n  // — modality-specific —\n  visual?: VisualMeta\n  text?: TextMeta\n  // — retrieval —\n  relevance: number // RRF fused score in 0..1; cross-source orderable, not absolute relevance\n  raw?: unknown\n}\n\nconst modalitySchema: z.ZodType<Modality> = z.enum(['image', 'video', 'audio', 'text'])\n\nexport const referenceSchema: z.ZodType<Reference> = z.object({\n  id: z.string().min(1),\n  modality: modalitySchema,\n  title: z.string().optional(),\n  source: z.object({ providerId: z.string().min(1), sourceUrl: z.string().min(1) }),\n  canonicalUrl: z.string().min(1),\n  rights: rightsRecordSchema,\n  verifiedAt: z.string().datetime(),\n  thumbnail: z.object({ url: z.string(), width: z.number().optional(), height: z.number().optional() }).optional(),\n  preview: z.object({ url: z.string(), mediaType: z.string(), width: z.number().optional(), height: z.number().optional() }).optional(),\n  perceptualHash: z.string().optional(),\n  visual: z.object({ width: z.number(), height: z.number(), dominantColors: z.array(z.string()).optional() }).optional(),\n  text: z.object({\n    excerpt: z.string(),\n    excerptKind: z.enum(['passage', 'structure', 'quote']),\n    locator: z.string().optional(),\n  }).optional(),\n  relevance: z.number().min(0).max(1),\n  raw: z.unknown().optional(),\n})\n\n/** Validate a provider-emitted reference at the core boundary. Throws on malformed input. */\nexport function parseReference(input: unknown): Reference {\n  return referenceSchema.parse(input)\n}\n","// FNV-1a 32-bit, base36. Deterministic, dependency-free, runtime-agnostic.\n// Used only for content-addressed ids / dedup keys — not for security.\nexport function fnv1a(str: string): string {\n  let h = 0x811c9dc5\n  for (let i = 0; i < str.length; i++) {\n    h ^= str.charCodeAt(i)\n    h = Math.imul(h, 0x01000193)\n  }\n  return (h >>> 0).toString(36)\n}\n","import { fnv1a } from './hash'\n\n// Conservative URL canonicalization: lowercase scheme+host, drop fragment + a single\n// trailing slash. Path case and query are preserved (some sources are case-sensitive).\nexport function canonicalizeUrl(url: string): string {\n  try {\n    const u = new URL(url)\n    u.hash = ''\n    u.protocol = u.protocol.toLowerCase()\n    u.hostname = u.hostname.toLowerCase()\n    let out = u.toString()\n    if (out.endsWith('/') && !out.endsWith('://')) out = out.slice(0, -1)\n    return out\n  } catch {\n    return url\n  }\n}\n\n/** Content-addressed id: stable within a result set, not promised across calls. */\nexport function referenceId(providerId: string, sourceUrl: string): string {\n  return `${providerId}:${fnv1a(canonicalizeUrl(sourceUrl))}`\n}\n","import type { Reference } from './reference'\nimport { canonicalizeUrl } from './dedup-key'\n\nconst HEX_BITS: Record<string, number> = {\n  '0': 0, '1': 1, '2': 1, '3': 2, '4': 1, '5': 2, '6': 2, '7': 3,\n  '8': 1, '9': 2, a: 2, b: 3, c: 2, d: 3, e: 3, f: 4,\n}\n\n/** Bitwise hamming distance between two equal-length lowercase hex strings. */\nexport function hammingDistance(a: string, b: string): number {\n  if (a.length !== b.length) return Infinity\n  let d = 0\n  for (let i = 0; i < a.length; i++) {\n    if (a[i] === b[i]) continue\n    const xor = (parseInt(a[i], 16) ^ parseInt(b[i], 16)).toString(16)\n    d += HEX_BITS[xor] ?? 4\n  }\n  return d\n}\n\nexport interface DedupeOptions {\n  /** Max hamming distance between perceptual hashes to treat as duplicates. Default 0 (off). */\n  hashThreshold?: number\n}\n\n// Collapse duplicates, keeping the highest-relevance representative. Two passes:\n// 1) exact canonical-URL match; 2) perceptual-hash within threshold (if both present).\n// Pure: never decodes bytes — operates only on caller-supplied perceptualHash strings.\nexport function dedupeReferences(refs: Reference[], opts: DedupeOptions = {}): Reference[] {\n  const threshold = opts.hashThreshold ?? 0\n  const kept: Reference[] = []\n  const byUrl = new Map<string, number>() // canonicalUrl -> index in kept\n\n  for (const ref of refs) {\n    const url = canonicalizeUrl(ref.canonicalUrl)\n    const urlHit = byUrl.get(url)\n    if (urlHit !== undefined) {\n      if (ref.relevance > kept[urlHit].relevance) kept[urlHit] = ref\n      continue\n    }\n\n    let merged = false\n    if (threshold > 0 && ref.perceptualHash) {\n      // NOTE (P1): perceptual hashes must be equal-length across providers or they silently\n      // won't hash-dedupe — hammingDistance returns Infinity for unequal lengths.\n      for (let i = 0; i < kept.length; i++) {\n        const k = kept[i]\n        if (k.perceptualHash && hammingDistance(ref.perceptualHash, k.perceptualHash) <= threshold) {\n          if (ref.relevance > k.relevance) {\n            byUrl.delete(canonicalizeUrl(k.canonicalUrl))\n            byUrl.set(canonicalizeUrl(ref.canonicalUrl), i)\n            kept[i] = ref\n          }\n          merged = true\n          break\n        }\n      }\n    }\n    if (merged) continue\n\n    byUrl.set(url, kept.length)\n    kept.push(ref)\n  }\n  return kept\n}\n","import type { Reference } from './reference'\nimport { canonicalizeUrl } from './dedup-key'\nimport { dedupeReferences, type DedupeOptions } from './dedup'\n\nexport interface MergeOptions extends DedupeOptions {\n  /** RRF dampening constant. Standard default 60. */\n  k?: number\n}\n\n// Reciprocal Rank Fusion across per-source ranked lists. Each list is assumed already\n// ordered best-first by its source. The same item (by canonical URL) appearing across\n// lists accumulates score, so cross-source agreement floats to the top — without\n// needing comparable absolute scores. Output relevance is max-normalized to 0..1.\nexport function mergeReferences(perSource: Reference[][], opts: MergeOptions = {}): Reference[] {\n  const k = opts.k ?? 60\n  const score = new Map<string, number>() // dedup key -> accumulated RRF score\n  const rep = new Map<string, Reference>() // dedup key -> best representative\n\n  for (const list of perSource) {\n    list.forEach((ref, rank) => {\n      const key = canonicalizeUrl(ref.canonicalUrl)\n      score.set(key, (score.get(key) ?? 0) + 1 / (k + rank))\n      const cur = rep.get(key)\n      if (!cur || ref.relevance > cur.relevance) rep.set(key, ref)\n    })\n  }\n\n  // `score` always has ≥1 entry here (we only reach this after building it from\n  // non-empty per-source lists; empty input returns [] earlier). Normalize by the\n  // actual max so the top result's relevance is exactly 1.0.\n  const maxScore = Math.max(...score.values())\n  const fused: Reference[] = [...score.entries()]\n    .map(([key, s]) => ({ ...rep.get(key)!, relevance: s / maxScore }))\n    .sort((a, b) => b.relevance - a.relevance)\n\n  // Perceptual-hash dedup as a second pass (URL dedup already happened via the key map).\n  return dedupeReferences(fused, opts)\n}\n","import { factsFor, type Tri } from './license'\nimport type { RightsRecord } from './rights'\n\nexport type Intent = 'internal-moodboard' | 'commercial-product' | 'ai-generation-input' | 'redistribution'\nexport type Decision = 'allowed' | 'allowed-with-attribution' | 'denied' | 'needs-review'\n\nexport interface Verdict {\n  decision: Decision\n  reasons: string[]\n  confidence: 'high' | 'low'\n  disclaimer: string\n}\n\nexport const NOT_LEGAL_ADVICE =\n  'Heuristic based on source-declared license/ToS facts; not legal advice.'\n\n// Which permission(s) an intent requires to be granted (true).\n// strict-deny: a required permission that is false → denied; 'unknown' → needs-review.\nfunction requiredPermissions(intent: Intent): Array<keyof ReturnType<typeof factsFor>> {\n  switch (intent) {\n    case 'commercial-product': return ['commercialUse']\n    case 'ai-generation-input': return ['commercialUse', 'derivatives']\n    case 'redistribution': return ['redistribution']\n    case 'internal-moodboard': return [] // lenient; gated only by the unknown/proprietary checks below\n  }\n}\n\nexport function evaluateUse(\n  r: RightsRecord,\n  intent: Intent,\n  ctx?: { userJurisdiction?: string },\n): Verdict {\n  const facts = factsFor(r.license)\n  const reasons: string[] = []\n  const confidence: 'high' | 'low' = r.license === 'unknown' ? 'low' : 'high'\n  const base = { reasons, confidence, disclaimer: NOT_LEGAL_ADVICE }\n\n  const commercialIntent = intent === 'commercial-product' || intent === 'ai-generation-input'\n\n  // Unknown license: never allowed — needs-review regardless of intent.\n  if (r.license === 'unknown') {\n    reasons.push('license could not be determined (strict-deny)')\n    return { decision: 'needs-review', ...base }\n  }\n\n  // editorial-only blocks commercial/AI use outright.\n  if (r.editorialOnly && commercialIntent) {\n    reasons.push('source marked editorial-only')\n    return { decision: 'denied', ...base }\n  }\n\n  // Jurisdiction (P0 minimal): if both the source jurisdiction and a user jurisdiction\n  // are known and differ, defer to human review. Full logic is P2.\n  if (ctx?.userJurisdiction && r.jurisdiction && ctx.userJurisdiction !== r.jurisdiction) {\n    reasons.push(`source jurisdiction ${r.jurisdiction} != user jurisdiction ${ctx.userJurisdiction}`)\n    return { decision: 'needs-review', ...base }\n  }\n\n  // Evaluate the required permissions with strict-deny semantics.\n  for (const perm of requiredPermissions(intent)) {\n    const value = facts[perm] as Tri\n    if (value === false) {\n      reasons.push(`${perm} not granted by ${r.license}`)\n      return { decision: 'denied', ...base }\n    }\n    if (value === 'unknown') {\n      reasons.push(`${perm} undetermined for ${r.license}`)\n      return { decision: 'needs-review', ...base }\n    }\n  }\n\n  reasons.push(`permitted for ${intent} under ${r.license}`)\n  // internal-moodboard is lenient: attribution not enforced for internal-only use.\n  if (facts.attributionRequired && intent === 'internal-moodboard') {\n    reasons.push('attribution required by license but not enforced for internal-moodboard use')\n  }\n  const decision: Decision =\n    facts.attributionRequired && intent !== 'internal-moodboard'\n      ? 'allowed-with-attribution'\n      : 'allowed'\n  return { decision, ...base }\n}\n","import type { Modality } from './modality'\nimport type { Reference } from './reference'\n\nexport type QueryFeature =\n  | 'keyword'\n  | 'color'\n  | 'orientation'\n  | 'license-filter'\n  | 'author'\n  | 'language'\n\nexport interface SearchFilters {\n  color?: string\n  orientation?: 'landscape' | 'portrait' | 'square'\n  language?: string\n}\n\nexport interface NormalizedQuery {\n  text: string\n  modalities: Modality[]\n  filters?: SearchFilters\n  limit?: number\n}\n\nexport interface KeyValueCache {\n  get(key: string): Promise<string | undefined>\n  set(key: string, value: string, ttlMs?: number): Promise<void>\n}\n\n// Injected by the host/client. core defines the port; providers call `ctx.fetch`.\n// core itself never references a global fetch nor hard-codes an endpoint (zero-network).\nexport interface ProviderContext {\n  fetch: typeof fetch\n  cache?: KeyValueCache\n  signal?: AbortSignal\n}\n\n// 4 load-bearing fields. Keys are held by the provider's factory closure\n// (e.g. `unsplash({ accessKey })`), not declared here; rate-limit metadata is added\n// in P1 when the orchestrator implements throttling.\nexport interface ReferenceProvider {\n  id: string\n  modalities: Modality[]\n  queryFeatures: QueryFeature[]\n  search(query: NormalizedQuery, ctx: ProviderContext): Promise<Reference[]>\n}\n\n/** Identity helper for type inference when authoring a provider factory. */\nexport function defineProvider(p: ReferenceProvider): ReferenceProvider {\n  return p\n}\n","import type { Modality } from './modality'\nimport type { NormalizedQuery, ReferenceProvider, SearchFilters } from './provider'\n\n// Build a per-provider NormalizedQuery: keep only the filters this provider's\n// queryFeatures support (silently drop the rest — never error), and intersect modalities.\nexport function normalizeQuery(\n  input: { query: string; modalities: Modality[]; filters?: SearchFilters; limit?: number },\n  provider: ReferenceProvider,\n): NormalizedQuery {\n  const feats = new Set(provider.queryFeatures)\n  const filters: SearchFilters = {}\n  if (input.filters?.color && feats.has('color')) filters.color = input.filters.color\n  if (input.filters?.orientation && feats.has('orientation')) filters.orientation = input.filters.orientation\n  if (input.filters?.language && feats.has('language')) filters.language = input.filters.language\n  const hasFilters = Object.keys(filters).length > 0\n  return {\n    text: input.query,\n    modalities: input.modalities.filter(m => provider.modalities.includes(m)),\n    ...(hasFilters ? { filters } : {}),\n    ...(input.limit !== undefined ? { limit: input.limit } : {}),\n  }\n}\n","import type { Reference } from './reference'\nimport { parseReference } from './reference'\nimport type { Modality } from './modality'\nimport type { Intent, Verdict } from './evaluate-use'\nimport { evaluateUse } from './evaluate-use'\nimport type { Attribution } from './attribution'\nimport { buildAttribution } from './attribution'\nimport type { ReferenceProvider, ProviderContext, KeyValueCache, SearchFilters } from './provider'\nimport { mergeReferences, type MergeOptions } from './merge'\nimport { normalizeQuery } from './query'\n\nexport interface RefkitOptions {\n  providers: ReferenceProvider[]\n  fetch?: typeof fetch // optional; defaults to globalThis.fetch\n  cache?: KeyValueCache\n  signal?: AbortSignal\n  merge?: MergeOptions\n}\n\nexport interface ProviderError {\n  providerId: string\n  error: unknown\n}\n\nexport interface SearchInput {\n  query: string\n  modalities: Modality[]\n  filters?: SearchFilters\n  limit?: number\n  signal?: AbortSignal\n  gateFor?: Intent\n  onProviderError?: (e: ProviderError) => void\n  rerank?: (refs: Reference[]) => Reference[] | Promise<Reference[]>\n}\n\nexport interface RefkitClient {\n  search(input: SearchInput): Promise<Reference[]>\n  evaluateUse(ref: Reference, intent: Intent, ctx?: { userJurisdiction?: string }): Verdict\n  buildAttribution(ref: Reference): Attribution\n  readonly providers: readonly ReferenceProvider[]\n}\n\nconst DEFAULT_LIMIT = 30\n\nexport function createRefkit(options: RefkitOptions): RefkitClient {\n  if (!options.providers || options.providers.length === 0) {\n    throw new Error('createRefkit: at least one provider is required')\n  }\n\n  async function search(input: SearchInput): Promise<Reference[]> {\n    const doFetch = options.fetch ?? globalThis.fetch\n    if (typeof doFetch !== 'function') {\n      throw new Error('createRefkit: no fetch available — pass options.fetch')\n    }\n    const ctx: ProviderContext = {\n      fetch: doFetch,\n      cache: options.cache,\n      signal: input.signal ?? options.signal,\n    }\n\n    const chosen = options.providers.filter(p => p.modalities.some(m => input.modalities.includes(m)))\n    if (chosen.length === 0) {\n      throw new Error(`refkit.search: no registered provider supports modalities [${input.modalities.join(', ')}]`)\n    }\n    const settled = await Promise.allSettled(chosen.map(p => p.search(normalizeQuery(input, p), ctx)))\n\n    const perSource: Reference[][] = []\n    let anyOk = false\n    settled.forEach((res, i) => {\n      const provider = chosen[i]\n      if (res.status === 'fulfilled') {\n        anyOk = true\n        const valid: Reference[] = []\n        for (const raw of res.value) {\n          try {\n            valid.push(parseReference(raw))\n          } catch (error) {\n            input.onProviderError?.({ providerId: provider.id, error })\n          }\n        }\n        perSource.push(valid)\n      } else {\n        input.onProviderError?.({ providerId: provider.id, error: res.reason })\n      }\n    })\n\n    if (!anyOk) {\n      const reasons = settled\n        .filter((s): s is PromiseRejectedResult => s.status === 'rejected')\n        .map(s => s.reason)\n      throw new AggregateError(reasons, 'refkit.search: all providers failed')\n    }\n\n    let refs = mergeReferences(perSource, options.merge)\n    if (input.rerank) refs = await input.rerank(refs)\n    if (input.gateFor) {\n      const intent = input.gateFor\n      refs = refs.filter(r => evaluateUse(r.rights, intent).decision.startsWith('allowed'))\n    }\n    return refs.slice(0, input.limit ?? DEFAULT_LIMIT)\n  }\n\n  return {\n    search,\n    evaluateUse: (ref, intent, ctx) => evaluateUse(ref.rights, intent, ctx),\n    buildAttribution: ref =>\n      buildAttribution({\n        license: ref.rights.license,\n        author: ref.rights.author,\n        title: ref.title,\n        canonicalUrl: ref.canonicalUrl,\n      }),\n    get providers() {\n      return options.providers\n    },\n  }\n}\n"],"mappings":"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","names":["z","z"]}

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "@refkit/core",
+  "version": "0.1.0",
+  "description": "refkit core — neutral reference-retrieval brain: Reference/RightsRecord contract, license normalization, strict-deny use-gate, RRF merge/dedup, ReferenceProvider interfaces. Zero-network, zero-provider, only zod.",
+  "type": "module",
+  "license": "Apache-2.0",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "LICENSE"
+  ],
+  "dependencies": {
+    "zod": "^4.3.6"
+  },
+  "scripts": {
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest watch",
+    "build": "tsup"
+  }
+}