polen 0.11.0-next.2 → 0.11.0-next.20

package/src/lib/kit-temp/effect.union-adt.test.ts

@@ -0,0 +1,81 @@
+import { EffectKit } from '#lib/kit-temp/$$'
+import { expect } from 'vitest'
+import { Test } from '../../../tests/unit/helpers/test.js'
+
+const UnionAdt = EffectKit.Schema.UnionAdt
+
+interface ParseCase {
+  tags: string[]
+  expected: ReturnType<typeof UnionAdt.parse>
+}
+
+// dprint-ignore
+Test.suite<ParseCase>('parse', [
+  { name: 'CatalogVersioned, CatalogUnversioned -> Catalog ADT',                                       tags: ['CatalogVersioned', 'CatalogUnversioned'], expected: { name: 'Catalog', members: [{ tag: 'CatalogVersioned', memberName: 'Versioned' }, { tag: 'CatalogUnversioned', memberName: 'Unversioned' }] } },
+  { name: 'SchemaVersioned, SchemaUnversioned -> Schema ADT',                                          tags: ['SchemaVersioned', 'SchemaUnversioned'],
+    expected: {
+      name: 'Schema',
+      members: [{ tag: 'SchemaVersioned', memberName: 'Versioned' }, {
+        tag: 'SchemaUnversioned',
+        memberName: 'Unversioned',
+      }],
+    },
+  },
+  { name: 'User, Post -> null (non-ADT)',                                                              tags: ['User', 'Post'], expected: null },
+  { name: 'CatalogVersioned, User -> null (mixed ADT)',                                                tags: ['CatalogVersioned', 'User'], expected: null },
+  { name: 'CatalogVersioned -> null (only one member)',                                                tags: ['CatalogVersioned'], expected: null },
+  { name: 'empty array -> null',                                                                       tags: [], expected: null },
+], ({ tags, expected }) => {
+  expect(UnionAdt.parse(tags)).toEqual(expected)
+})
+
+interface IsADTMemberCase {
+  tag: string
+  allTags: string[]
+  expected: boolean
+}
+
+// dprint-ignore
+Test.suite<IsADTMemberCase>('isADTMember', [
+  { name: 'CatalogVersioned in [CatalogVersioned, CatalogUnversioned] -> true',                        tag: 'CatalogVersioned', allTags: ['CatalogVersioned', 'CatalogUnversioned'], expected: true },
+  { name: 'CatalogUnversioned in [CatalogVersioned, CatalogUnversioned] -> true',                      tag: 'CatalogUnversioned', allTags: ['CatalogVersioned', 'CatalogUnversioned'], expected: true },
+  { name: 'User in [CatalogVersioned, CatalogUnversioned, User] -> false',                             tag: 'User', allTags: ['CatalogVersioned', 'CatalogUnversioned', 'User'], expected: false },
+  { name: 'CatalogVersioned in [CatalogVersioned] -> false (only one member)',                         tag: 'CatalogVersioned', allTags: ['CatalogVersioned'], expected: false },
+  { name: 'userProfile in [userProfile, userSettings] -> false (lowercase)',                           tag: 'userProfile', allTags: ['userProfile', 'userSettings'], expected: false },
+], ({ tag, allTags, expected }) => {
+  expect(UnionAdt.isADTMember(tag, allTags)).toBe(expected)
+})
+
+interface GetADTInfoCase {
+  tag: string
+  allTags: string[]
+  expected: ReturnType<typeof UnionAdt.getADTInfo>
+}
+
+// dprint-ignore
+Test.suite<GetADTInfoCase>('getADTInfo', [
+  { name: 'CatalogVersioned -> { adtName: Catalog, memberName: Versioned }',                           tag: 'CatalogVersioned', allTags: ['CatalogVersioned', 'CatalogUnversioned'], expected: { adtName: 'Catalog', memberName: 'Versioned' } },
+  { name: 'SchemaUnversioned -> { adtName: Schema, memberName: Unversioned }',                         tag: 'SchemaUnversioned',
+    allTags: ['SchemaVersioned', 'SchemaUnversioned'],
+    expected: { adtName: 'Schema', memberName: 'Unversioned' },
+  },
+  { name: 'User -> null (non-ADT)',                                                                    tag: 'User', allTags: ['User', 'Post'], expected: null },
+  { name: 'CatalogVersioned -> null (only one member)',                                                tag: 'CatalogVersioned', allTags: ['CatalogVersioned'], expected: null },
+], ({ tag, allTags, expected }) => {
+  expect(UnionAdt.getADTInfo(tag, allTags)).toEqual(expected)
+})
+
+interface FormatADTTagCase {
+  adtName: string
+  memberName: string
+  expected: string
+}
+
+// dprint-ignore
+Test.suite<FormatADTTagCase>('formatADTTag', [
+  { name: 'Catalog + Versioned -> CatalogVersioned',                                                   adtName: 'Catalog', memberName: 'Versioned', expected: 'CatalogVersioned' },
+  { name: 'Schema + Unversioned -> SchemaUnversioned',                                                 adtName: 'Schema', memberName: 'Unversioned', expected: 'SchemaUnversioned' },
+  { name: 'Revision + Initial -> RevisionInitial',                                                     adtName: 'Revision', memberName: 'Initial', expected: 'RevisionInitial' },
+], ({ adtName, memberName, expected }) => {
+  expect(UnionAdt.formatADTTag(adtName, memberName)).toBe(expected)
+})

package/src/lib/kit-temp/global-local-check.ts

@@ -0,0 +1,179 @@
+import { FileSystem, Path } from '@effect/platform'
+import { Effect } from 'effect'
+import * as path from 'node:path'
+
+interface GlobalLocalCheckOptions {
+  /**
+   * The package name to check for (e.g., 'polen', 'eslint', etc.)
+   */
+  packageName: string
+  /**
+   * The current executable path (typically process.argv[1])
+   */
+  currentExecutablePath: string
+  /**
+   * The flag name to bypass the check (default: '--allow-global')
+   */
+  allowGlobalFlag?: string
+  /**
+   * Custom error message template
+   */
+  errorMessageTemplate?: {
+    title?: string
+    explanation?: string
+    solutions?: string[]
+    bypassInstructions?: string
+  }
+}
+
+interface PackageJson {
+  dependencies?: Record<string, string>
+  devDependencies?: Record<string, string>
+  peerDependencies?: Record<string, string>
+}
+
+/**
+ * Check if a package exists in any package.json from the current directory up to root
+ */
+const findPackageInAncestors = (packageName: string): Effect.Effect<string | null, Error, FileSystem.FileSystem> =>
+  Effect.gen(function*() {
+    let dir = process.cwd()
+
+    while (true) {
+      const packageJsonPath = path.join(dir, 'package.json')
+      const fs = yield* FileSystem.FileSystem
+
+      try {
+        const content = yield* fs.readFileString(packageJsonPath)
+        const pkg: PackageJson = JSON.parse(content)
+
+        if (
+          pkg.dependencies?.[packageName]
+          || pkg.devDependencies?.[packageName]
+          || pkg.peerDependencies?.[packageName]
+        ) {
+          return dir
+        }
+      } catch {
+        // No package.json in this directory, continue
+      }
+
+      const parent = path.dirname(dir)
+      if (parent === dir) {
+        // Reached root directory
+        break
+      }
+      dir = parent
+    }
+
+    return null
+  })
+
+/**
+ * Create a descriptive error for global vs local package conflicts
+ */
+function createGlobalLocalConflictError(
+  packageName: string,
+  projectDir: string,
+  template?: GlobalLocalCheckOptions['errorMessageTemplate'],
+): Error {
+  const defaultSolutions = [
+    `pnpm exec ${packageName} <command>`,
+    `npx ${packageName} <command>`,
+    `./node_modules/.bin/${packageName} <command>`,
+  ]
+
+  const title = template?.title || `Global ${packageName} running in project with local ${packageName}`
+  const explanation = template?.explanation
+    || `This project has ${packageName} in its package.json at ${projectDir}, but you're using a global ${packageName} installation. `
+      + `This can cause version mismatches and unexpected behavior.`
+  const solutions = template?.solutions || defaultSolutions
+  const bypassInstructions = template?.bypassInstructions || `${packageName} <command> --allow-global`
+
+  const message = `
+${title}
+
+${explanation}
+
+To use the project's ${packageName}:
+${solutions.map(s => `  • ${s}`).join('\n')}
+
+To bypass this check:
+  • ${bypassInstructions}
+`.trim()
+
+  return new Error(message)
+}
+
+/**
+ * Check if a globally installed package is being run in a project that has the package installed locally.
+ * This helps prevent version conflicts and confusion.
+ *
+ * @example
+ * ```typescript
+ * // In your CLI entry point
+ * await Effect.runPromise(
+ *   Effect.provide(
+ *     checkGlobalVsLocal({
+ *       packageName: 'my-cli',
+ *       currentExecutablePath: process.argv[1]
+ *     }),
+ *     NodeFileSystem.layer
+ *   )
+ * )
+ * ```
+ */
+export const checkGlobalVsLocal = (
+  options: GlobalLocalCheckOptions,
+): Effect.Effect<void, Error, FileSystem.FileSystem> =>
+  Effect.gen(function*() {
+    const {
+      packageName,
+      currentExecutablePath,
+      allowGlobalFlag = '--allow-global',
+    } = options
+
+    // Check if running from global install
+    // Common global installation patterns:
+    // - pnpm: /Users/.../Library/pnpm/packagename
+    // - npm: /usr/local/lib/node_modules/packagename
+    // - yarn: /Users/.../config/yarn/global/node_modules/packagename
+    const isGlobalInstall = currentExecutablePath.includes('pnpm/global')
+      || currentExecutablePath.includes('.npm/global')
+      || currentExecutablePath.includes('yarn/global')
+      || currentExecutablePath.includes(`/Library/pnpm/${packageName}`)
+      || currentExecutablePath.includes('/usr/local/lib/node_modules/')
+      || currentExecutablePath.includes('/usr/lib/node_modules/')
+      || !currentExecutablePath.includes(`node_modules/${packageName}`)
+
+    if (!isGlobalInstall) {
+      // Running from local install, all good
+      return
+    }
+
+    // Check for bypass flag
+    if (process.argv.includes(allowGlobalFlag)) {
+      return
+    }
+
+    // Check if package exists in any ancestor package.json
+    const projectDir = yield* findPackageInAncestors(packageName)
+
+    if (projectDir) {
+      return yield* Effect.fail(createGlobalLocalConflictError(packageName, projectDir, options.errorMessageTemplate))
+    }
+  })
+
+/**
+ * Legacy Promise-based wrapper for backward compatibility.
+ * @deprecated Use the Effect-based version with appropriate Effect runtime
+ */
+export async function checkGlobalVsLocalAsync(options: GlobalLocalCheckOptions): Promise<void> {
+  const { NodeFileSystem } = await import('@effect/platform-node')
+  return Effect.runPromise(
+    Effect.provide(
+      checkGlobalVsLocal(options),
+      NodeFileSystem.layer,
+    ),
+  )
+}

package/src/lib/kit-temp/ob.ts

@@ -0,0 +1,32 @@
+import type * as TF from 'type-fest'
+
+export type PickWhereValueExtends<$Obj extends object, $Constraint> = {
+  [k in keyof $Obj as $Obj[k] extends $Constraint ? k : never]: $Obj[k]
+}
+
+export type Values<$Obj extends object> = $Obj[keyof $Obj]
+
+export type ReplaceProperty<$Obj extends object, $Key extends keyof $Obj, $NewType> =
+  & Omit<$Obj, $Key>
+  & {
+    [_ in $Key]: $NewType
+  }
+
+export type IsEmpty<$Obj extends object> = keyof $Obj extends never ? true : false
+
+export type KeysArray<$Obj extends object> = Array<keyof $Obj>
+
+export type KeysReadonlyArray<$Obj extends object> = ReadonlyArray<keyof $Obj>
+
+export type OnlyKeysInArray<$Obj extends object, $KeysArray extends readonly string[]> = {
+  [k in keyof $Obj as k extends $KeysArray[number] ? k : never]: $Obj[k]
+}
+
+export type Writeable<$Obj extends object> = TF.Writable<$Obj>
+
+export const mapValues = <rec extends Record<PropertyKey, any>, newValue>(
+  obj: rec,
+  fn: (value: rec[keyof rec], key: keyof rec) => newValue,
+): Record<PropertyKey, newValue> => {
+  return Object.fromEntries(Object.entries(obj).map((k, v) => [k, fn(v as any, k as any)]))
+}

package/src/lib/kit-temp/other.test-d.ts

@@ -0,0 +1,120 @@
+import { Ts } from '@wollybeard/kit'
+import { objFilter, ObjOmit, ObjPick, objPolicyFilter } from './other.js'
+import type { ObjPolicyFilter } from './other.js'
+
+// Test object for all tests
+interface TestObj {
+  a: string
+  b: number
+  c: boolean
+  d: string[]
+}
+declare const testObj: TestObj
+
+// Test 1: objPolicyFilter with allow mode
+{
+  const result = objPolicyFilter(`allow`, testObj, [`a`, `c`] as const)
+  Ts.assertEqual<{ a: string; c: boolean }>()(result)
+}
+
+// Test 2: objPolicyFilter with deny mode
+{
+  const result = objPolicyFilter(`deny`, testObj, [`a`, `c`] as const)
+  Ts.assertEqual<{ b: number; d: string[] }>()(result)
+}
+
+// Test 3: objFilter returns Partial<T>
+{
+  const result = objFilter(testObj, (key, value) => value !== `hello`)
+  Ts.assertEqual<Partial<TestObj>>()(result)
+
+  // All properties are optional
+  Ts.assertSub<typeof result.a>()(undefined)
+  Ts.assertSub<typeof result.b>()(undefined)
+  Ts.assertSub<typeof result.c>()(undefined)
+  Ts.assertSub<typeof result.d>()(undefined)
+}
+
+// Test 4: ObjPick type inference
+{
+  const result = ObjPick(testObj, [`a`, `c`] as const)
+  Ts.assertEqual<{ a: string; c: boolean }>()(result)
+}
+
+// Test 5: ObjOmit type inference
+{
+  const result = ObjOmit(testObj, [`a`, `c`] as const)
+  Ts.assertEqual<{ b: number; d: string[] }>()(result)
+}
+
+// Test 6: ObjPolicyFilter type-level function
+{
+  type Allow = ObjPolicyFilter<TestObj, `a` | `c`, `allow`>
+  type _TestAllow = Ts.AssertExact<Allow, { a: string; c: boolean }>
+
+  type Deny = ObjPolicyFilter<TestObj, `a` | `c`, `deny`>
+  type _TestDeny = Ts.AssertExact<Deny, { b: number; d: string[] }>
+
+  type AllowEmpty = ObjPolicyFilter<TestObj, never, `allow`>
+  type _TestAllowEmpty = Ts.AssertExact<AllowEmpty, {}>
+
+  type DenyEmpty = ObjPolicyFilter<TestObj, never, `deny`>
+  type _TestDenyEmpty = Ts.AssertExact<DenyEmpty, TestObj>
+}
+
+// Test 7: Edge cases
+{
+  // Empty object
+  const empty = {}
+  const allowEmpty = objPolicyFilter(`allow`, empty, [])
+  const denyEmpty = objPolicyFilter(`deny`, empty, [])
+  const filterEmpty = objFilter(empty, () => true)
+
+  Ts.assertEqual<{}>()(allowEmpty)
+  Ts.assertEqual<{}>()(denyEmpty)
+  Ts.assertEqual<{}>()(filterEmpty)
+
+  // Single property object
+  const single = { a: 1 }
+  const allowSingle = objPolicyFilter(`allow`, single, [`a`] as const)
+  const denySingle = objPolicyFilter(`deny`, single, [`a`] as const)
+  const filterSingle = objFilter(single, () => true)
+
+  Ts.assertEqual<{ a: number }>()(allowSingle)
+  Ts.assertEqual<{}>()(denySingle)
+  Ts.assertEqual<{ a?: number }>()(filterSingle)
+}
+
+// Test 8: Complex nested object
+{
+  interface ComplexObj {
+    nested: { a: string; b: number }
+    array: string[]
+    optional?: boolean
+    readonly ro: string
+  }
+  const complexObj = {} as ComplexObj
+
+  const picked = objPolicyFilter(`allow`, complexObj, [`nested`, `optional`] as const)
+  Ts.assertEqual<{ nested: { a: string; b: number }; optional?: boolean }>()(picked)
+
+  const omitted = objPolicyFilter(`deny`, complexObj, [`nested`, `optional`] as const)
+  Ts.assertEqual<{ array: string[]; readonly ro: string }>()(omitted)
+
+  const filtered = objFilter(complexObj, (key) => key !== `array`)
+  Ts.assertEqual<Partial<ComplexObj>>()(filtered)
+}
+
+// Test 9: Keys parameter type inference
+{
+  // With const assertion
+  const keys1 = [`a`, `c`] as const
+  const result1 = objPolicyFilter(`allow`, testObj, keys1)
+  Ts.assertEqual<{ a: string; c: boolean }>()(result1)
+
+  // Without const assertion (wider type)
+  const keys2: (keyof TestObj)[] = [`a`, `c`]
+  const result2 = objPolicyFilter(`allow`, testObj, keys2)
+  // Result is a union of all possible picks
+  type Result2 = typeof result2 // Pick<TestObj, keyof TestObj>
+}

package/src/lib/kit-temp/other.test.ts

@@ -0,0 +1,256 @@
+import * as fc from 'fast-check'
+import { describe, expect, test } from 'vitest'
+import { objFilter, ObjOmit, ObjPick, objPolicyFilter, spreadShallow } from './other.js'
+
+describe('objPolicyFilter', () => {
+  const testObj = { a: 1, b: 2, c: 3, d: 4 }
+
+  test('allow mode picks specified keys', () => {
+    expect(objPolicyFilter('allow', testObj, ['a', 'c'])).toEqual({ a: 1, c: 3 })
+    expect(objPolicyFilter('allow', testObj, [])).toEqual({})
+    expect(objPolicyFilter('allow', testObj, ['a', 'z'] as any)).toEqual({ a: 1 })
+  })
+
+  test('deny mode omits specified keys', () => {
+    expect(objPolicyFilter('deny', testObj, ['a', 'c'])).toEqual({ b: 2, d: 4 })
+    expect(objPolicyFilter('deny', testObj, [])).toEqual(testObj)
+    expect(objPolicyFilter('deny', testObj, ['z'] as any)).toEqual(testObj)
+  })
+
+  test('preserves undefined values', () => {
+    const obj = { a: 1, b: undefined, c: 3 }
+    expect(objPolicyFilter('allow', obj, ['a', 'b'])).toEqual({ a: 1, b: undefined })
+  })
+})
+
+describe('objFilter', () => {
+  const testObj = { a: 1, b: 2, c: 3, d: 4 }
+
+  test('filters by predicates', () => {
+    // By value
+    expect(objFilter(testObj, (k, v) => v > 2)).toEqual({ c: 3, d: 4 })
+
+    // By key
+    expect(objFilter(testObj, k => k === 'a' || k === 'c')).toEqual({ a: 1, c: 3 })
+
+    // By full object context
+    expect(objFilter(testObj, (k, v, obj) => {
+      const avg = Object.values(obj).reduce((a, b) => a + b, 0) / Object.keys(obj).length
+      return v < avg
+    })).toEqual({ a: 1, b: 2 })
+  })
+
+  test('edge cases', () => {
+    expect(objFilter(testObj, () => false)).toEqual({})
+    expect(objFilter(testObj, () => true)).toEqual(testObj)
+    expect(objFilter({}, () => true)).toEqual({})
+  })
+})
+
+describe('ObjPick and ObjOmit', () => {
+  test('are aliases for objPolicyFilter', () => {
+    const obj = { a: 1, b: 2, c: 3 }
+    const keys = ['a', 'c'] as const
+
+    expect(ObjPick(obj, keys)).toEqual(objPolicyFilter('allow', obj, keys))
+    expect(ObjOmit(obj, keys)).toEqual(objPolicyFilter('deny', obj, keys))
+  })
+})
+
+describe('property-based tests', () => {
+  test('objPolicyFilter allow/deny are complementary', () => {
+    fc.assert(
+      fc.property(
+        fc.object(),
+        fc.array(fc.string()),
+        (obj, keys) => {
+          const allowed = objPolicyFilter('allow', obj, keys)
+          const denied = objPolicyFilter('deny', obj, keys)
+
+          // Every key in obj (own properties only) is either in allowed or denied, never both
+          Object.keys(obj).forEach(key => {
+            const inAllowed = Object.prototype.hasOwnProperty.call(allowed, key)
+            const inDenied = Object.prototype.hasOwnProperty.call(denied, key)
+            expect(inAllowed).toBe(!inDenied)
+          })
+
+          // Combined they reconstruct the original object's own properties
+          const reconstructed = { ...allowed, ...denied }
+
+          // Filter out inherited properties that may have been added from the keys
+          const filteredReconstructed = Object.keys(reconstructed)
+            .filter(key => Object.prototype.hasOwnProperty.call(obj, key))
+            .reduce<any>((acc, key) => {
+              acc[key] = (reconstructed as any)[key]
+              return acc
+            }, {})
+
+          const ownPropsObj = Object.keys(obj).reduce<any>((acc, key) => {
+            acc[key] = obj[key]
+            return acc
+          }, {})
+          expect(filteredReconstructed).toEqual(ownPropsObj)
+        },
+      ),
+    )
+  })
+
+  test('objFilter preserves values unchanged', () => {
+    fc.assert(
+      fc.property(
+        fc.object(),
+        (obj) => {
+          const filtered = objFilter(obj, () => true)
+
+          // Object.keys doesn't include __proto__, so we need to handle it specially
+          const objWithoutProto = Object.keys(obj).reduce<any>((acc, key) => {
+            acc[key] = obj[key]
+            return acc
+          }, {})
+
+          expect(filtered).toEqual(objWithoutProto)
+
+          // Values are the same reference
+          Object.keys(filtered).forEach(key => {
+            expect(filtered[key]).toBe(obj[key])
+          })
+        },
+      ),
+    )
+  })
+
+  test('objPolicyFilter is immutable', () => {
+    fc.assert(
+      fc.property(
+        fc.object(),
+        fc.array(fc.string()),
+        fc.oneof(fc.constant('allow' as const), fc.constant('deny' as const)),
+        (obj, keys, mode) => {
+          const original = { ...obj }
+          objPolicyFilter(mode, obj, keys)
+          expect(obj).toEqual(original)
+        },
+      ),
+    )
+  })
+
+  test('empty keys behavior', () => {
+    fc.assert(
+      fc.property(
+        fc.object(),
+        (obj) => {
+          expect(objPolicyFilter('allow', obj, [])).toEqual({})
+          expect(objPolicyFilter('deny', obj, [])).toEqual(obj)
+        },
+      ),
+    )
+  })
+})
+
+describe('mergeShallow', () => {
+  test('merges objects while omitting undefined values', () => {
+    const base = { a: 1, b: 2, c: 3 }
+    const override = { a: 1, b: undefined, c: 4, d: 5 }
+
+    expect(spreadShallow<any>(base, override)).toEqual({ a: 1, b: 2, c: 4, d: 5 })
+  })
+
+  test('handles multiple objects', () => {
+    const obj1 = { a: 1, b: 2 }
+    const obj2 = { a: 1, b: undefined, c: 3 }
+    const obj3 = { a: 1, b: 2, c: undefined, d: 4 }
+
+    expect(spreadShallow<any>(obj1, obj2, obj3)).toEqual({ a: 1, b: 2, c: 3, d: 4 })
+  })
+
+  test('handles empty objects', () => {
+    expect(spreadShallow({}, {})).toEqual({})
+    expect(spreadShallow({ a: 1 }, {})).toEqual({ a: 1 })
+    expect(spreadShallow({}, { a: 1 })).toEqual({ a: 1 })
+  })
+
+  test('handles single object', () => {
+    const obj = { a: 1, b: undefined, c: 3 }
+    expect(spreadShallow(obj)).toEqual({ a: 1, c: 3 })
+  })
+
+  test('handles no objects', () => {
+    expect(spreadShallow()).toEqual({})
+  })
+
+  test('handles undefined objects', () => {
+    const obj = { a: 1, b: 2 }
+    expect(spreadShallow(undefined, obj, undefined)).toEqual({ a: 1, b: 2 })
+    expect(spreadShallow(obj, undefined)).toEqual({ a: 1, b: 2 })
+    expect(spreadShallow(undefined, undefined)).toEqual({})
+  })
+
+  test('preserves null values', () => {
+    const obj1 = { a: 1, b: null }
+    const obj2 = { a: 1, b: 2, c: null }
+    expect(spreadShallow<any>(obj1, obj2)).toEqual({ a: 1, b: 2, c: null })
+  })
+
+  test('preserves false and 0 values', () => {
+    const obj1 = { a: true, b: 1 }
+    const obj2 = { a: false, b: 0 }
+    expect(spreadShallow(obj1, obj2)).toEqual({ a: false, b: 0 })
+  })
+
+  test('property-based: never includes undefined values', () => {
+    fc.assert(
+      fc.property(
+        fc.array(fc.dictionary(fc.string(), fc.option(fc.anything()))),
+        (objects) => {
+          const result = spreadShallow(...objects)
+          Object.values(result).forEach(value => {
+            expect(value).not.toBe(undefined)
+          })
+        },
+      ),
+    )
+  })
+
+  test('property-based: later objects override earlier ones', () => {
+    fc.assert(
+      fc.property(
+        fc.object(),
+        fc.object(),
+        fc.string().filter(k => k !== '__proto__' && k !== 'constructor' && k !== 'prototype'),
+        fc.anything().filter(v => v !== undefined),
+        (obj1, obj2, key, value) => {
+          // Set the same key in both objects
+          obj1[key] = 'first'
+          obj2[key] = value
+
+          const result = spreadShallow(obj1, obj2)
+          expect(result[key]).toBe(value)
+        },
+      ),
+    )
+  })
+
+  test('protects against prototype pollution', () => {
+    // Test __proto__ pollution attempt
+    const maliciousObj = { '__proto__': { polluted: true } } as any
+    const normalObj = { safe: 'value' }
+
+    const result = spreadShallow(normalObj, maliciousObj)
+
+    // The result should not have __proto__ key
+    expect(Object.prototype.hasOwnProperty.call(result, '__proto__')).toBe(false)
+
+    // The Object prototype should not be polluted
+    expect((Object.prototype as any).polluted).toBeUndefined()
+
+    // Test constructor pollution attempt
+    const constructorObj = { constructor: { polluted: true } } as any
+    const result2 = spreadShallow(normalObj, constructorObj)
+    expect(Object.prototype.hasOwnProperty.call(result2, 'constructor')).toBe(false)
+
+    // Test prototype pollution attempt
+    const prototypeObj = { prototype: { polluted: true } } as any
+    const result3 = spreadShallow(normalObj, prototypeObj)
+    expect(Object.prototype.hasOwnProperty.call(result3, 'prototype')).toBe(false)
+  })
+})